# Django 6.0.7 documentation

# Ramverket för syndikeringsflöden

Django levereras med ett ramverk för generering av syndikeringsflöden på hög nivå för att skapa RSS- och Atom-flöden.

Allt du behöver göra för att skapa ett syndikeringsflöde är att skriva en kort Python-klass. Du kan skapa så många flöden du vill.

Django levereras också med ett API för flödesgenerering på lägre nivå. Använd detta om du vill generera flöden utanför en webbkontext eller på något annat sätt på lägre nivå.

## Ramverket på hög nivå

### Översikt

Det högnivåramverk som genererar flöden tillhandahålls av klassen `Feed`. För att skapa ett flöde, skriv en `Feed`-klass och peka på en instans av den i din URLconf.

### klasserna `Feed`

En `Feed`-klass är en Python-klass som representerar ett syndikeringsflöde. Ett flöde kan vara enkelt (t.ex. ett flöde för ”webbplatsnyheter” eller ett grundläggande flöde som visar de senaste inläggen på en blogg) eller mer komplext (t.ex. ett flöde som visar alla blogginlägg i en viss kategori, där kategorin är variabel).

Feed-klasser underklassar `django.contrib.syndication.views.Feed`. De kan finnas var som helst i din kodbas.

Instanser av klasserna `Feed` är vyer som kan användas i ditt URLconf.

### Ett enkelt exempel

Detta enkla exempel, som hämtats från en hypotetisk webbplats för nyheter om polispatruller, beskriver ett flöde med de fem senaste nyheterna:

    from django.contrib.syndication.views import Feed
    from django.urls import reverse
    from policebeat.models import NewsItem

    class LatestEntriesFeed(Feed):
        title = "Police beat site news"
        link = "/sitenews/"
        description = "Updates on changes and additions to police beat central."

        def items(self):
            return NewsItem.objects.order_by("-pub_date")[:5]

        def item_title(self, item):
            return item.title

        def item_description(self, item):
            return item.description

        # item_link is only needed if NewsItem has no get_absolute_url method.
        def item_link(self, item):
            return reverse("news-item", args=[item.pk])

Om du vill ansluta en URL till detta flöde lägger du till en instans av Feed-objektet i ditt URLconf. Till exempel:

    from django.urls import path
    from myproject.feeds import LatestEntriesFeed

    urlpatterns = [
        # ...
        path("latest/feed/", LatestEntriesFeed()),
        # ...
    ]

Anteckning:

- Feed-klassen är en underklass till `django.contrib.syndication.views.Feed`.

- `title`, `link` och `description` motsvarar standard RSS-elementen `<title>`, `<link>` respektive `<description>`.

- `items()` är en metod som returnerar en lista med objekt som ska ingå i flödet som `<item>` element. Även om detta exempel returnerar `NewsItem`-objekt med hjälp av Djangos object-relational mapper, behöver `items()` inte returnera modellinstanser. Även om du får några bitar av funktionalitet ”gratis” genom att använda Django-modeller, kan `items()` returnera vilken typ av objekt du vill.

- Om du skapar ett Atom-flöde i stället för ett RSS-flöde anger du attributet `undertitel` i stället för attributet `beskrivning`. Se Publicera Atom- och RSS-flöden parallellt senare för ett exempel.

En sak är kvar att göra. I ett RSS-flöde har varje `<item>` en `<title>`, `<link>` och `<description>`. Vi måste tala om för ramverket vilka data som ska läggas in i dessa element.

- För innehållet i `<title>` och `<description>` försöker Django anropa metoderna `item_title()` och `item_description()` på `Feed`-klassen. De får en enda parameter, `item`, som är själva objektet. Dessa är valfria; som standard används strängrepresentationen av objektet för båda.

  Om du vill göra någon speciell formatering för antingen titeln eller beskrivningen kan Django templates användas istället. Deras sökvägar kan anges med attributen `title_template` och `description_template` på klassen `Feed`. Mallarna återges för varje objekt och skickas till två mallkontextvariabler:

  - `{{ obj }}` – Det aktuella objektet (ett av de objekt som du returnerade i `items()`)).

  - `{{ site }}` – Ett `django.contrib.sites.models.Site`-objekt som representerar den aktuella webbplatsen. Detta är användbart för `{{ site.domain }}` eller `{{ site.name }}`. Om du inte har Django sites-ramverket installerat kommer detta att ställas in till ett `RequestSite`-objekt. Se RequestSite-avsnittet i dokumentationen för sites-ramverket för mer information.

  Se ett komplext exempel nedan som använder en beskrivningsmall.

  Feed.get_context_data(**kwargs)

    Det finns också ett sätt att skicka ytterligare information till titel- och beskrivningsmallarna, om du behöver ange mer än de två variabler som nämns ovan. Du kan tillhandahålla din implementering av `get_context_data`-metoden i din `Feed`-underklass. Till exempel:

        from mysite.models import Article
        from django.contrib.syndication.views import Feed

        class ArticlesFeed(Feed):
            title = "My articles"
            description_template = "feeds/articles.html"

            def items(self):
                return Article.objects.order_by("-pub_date")[:5]

            def get_context_data(self, **kwargs):
                context = super().get_context_data(**kwargs)
                context["foo"] = "bar"
                return context

  Och mallen:

      Something about {{ foo }}: {{ obj.description }}

  Denna metod kommer att anropas en gång för varje objekt i listan som returneras av `items()` med följande nyckelordsargument:

  - `item`: det aktuella objektet. Av bakåtkompatibilitetsskäl är namnet på denna kontextvariabel `{{ obj }}`.

  - `obj`: det objekt som returneras av `get_object()`. Som standard är detta inte exponerat för mallarna för att undvika förväxling med `{{ obj }}` (se ovan), men du kan använda det i din implementering av `get_context_data()`.

  - `site`: aktuell plats enligt beskrivningen ovan.

  - `request`: aktuell förfrågan.

  Beteendet hos `get_context_data()` efterliknar det hos generic views - det är meningen att du ska anropa `super()` för att hämta kontextdata från överordnad klass, lägga till dina data och returnera den modifierade ordlistan.

- 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 is passed a single parameter, `item`. If that method doesn’t exist, Django tries executing a `get_absolute_url()` method on that object. Both `get_absolute_url()` and `item_link()` should return the item’s 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.

### Ett komplext exempel

Ramverket stöder också mer komplexa flöden, via argument.

En webbplats kan till exempel erbjuda ett RSS-flöde med de senaste brotten för varje polisområde i en stad. Det skulle vara dumt att skapa en separat `Feed`-klass för varje polisområde; det skulle bryta mot DRY-principen och skulle koppla data till programmeringslogik. Istället låter syndikeringsramverket dig komma åt de argument som skickas från din URLconf så att flöden kan mata ut objekt baserat på information i flödets URL.

Polisens beatfeeds kan nås via webbadresser som denna:

- `/beats/613/rss/` – Returnerar senaste brott för beat 613.

- `/beats/1424/rss/` – Returnerar senaste brott för beat 1424.

Dessa kan matchas med en URLconf rad såsom:

    path("beats/<int:beat_id>/rss/", BeatFeed()),

Precis som i en vy skickas argumenten i URL:en till metoden `get_object()` tillsammans med request-objektet.

Här är koden för dessa beat-specifika flöden:

    from django.contrib.syndication.views import Feed

    class BeatFeed(Feed):
        description_template = "feeds/beat_description.html"

        def get_object(self, request, beat_id):
            return Beat.objects.get(pk=beat_id)

        def title(self, obj):
            return "Police beat central: Crimes for beat %s" % obj.beat

        def link(self, obj):
            return obj.get_absolute_url()

        def description(self, obj):
            return "Crimes recently reported in police beat %s" % obj.beat

        def items(self, obj):
            return Crime.objects.filter(beat=obj).order_by("-crime_date")[:30]

För att generera flödets `<title>`, `<link>` och `<description>` använder Django metoderna `title()`, `link()` och `description()`. I det föregående exemplet var de klassattribut för strängar, men det här exemplet illustrerar att de kan vara antingen strängar * eller * metoder. För var och en av `title`, `link` och `description` följer Django denna algoritm:

- Först försöker den anropa en metod genom att skicka argumentet `obj`, där `obj` är det objekt som returneras av `get_object()`.

- Om det inte lyckas försöker den anropa en metod utan argument.

- Om så inte är fallet används class-attributet.

Observera också att `items()` också följer samma algoritm – först försöker den `items(obj)`, sedan `items()`, och slutligen ett `items` klassattribut (som borde vara en lista).

Vi använder en mall för artikelbeskrivningarna. Den kan vara så minimal som detta:

    {{ obj.description }}

Det står dig dock fritt att lägga till formatering om du så önskar.

Klassen `ExampleFeed` nedan ger fullständig dokumentation om metoder och attribut för `Feed` klasserna.

### Ange typ av foder

Som standard använder flöden som produceras i detta ramverk RSS 2.0.

För att ändra det, lägg till ett `feed_type`-attribut till din `Feed`-klass, så här:

    from django.utils.feedgenerator import Atom1Feed

    class MyFeed(Feed):
        feed_type = Atom1Feed

Observera att du anger `feed_type` till ett klassobjekt, inte en instans.

För närvarande finns följande fodertyper tillgängliga:

- `django.utils.feedgenerator.Rss201rev2Feed` (RSS 2.01. Standard.)

- `django.utils.feedgenerator.RssUserland091Feed` (RSS 0.91.)

- `django.utils.feedgenerator.Atom1Feed` (Atom 1.0.)

### Inneslutningar

Om du vill ange bilagor, t.ex. de som används för att skapa podcast-flöden, använder du hook `item_enclosures` eller, alternativt och om du bara har en enda bilaga per artikel, hooks `item_enclosure_url`, `item_enclosure_length` och `item_enclosure_mime_type`. Se klassen `ExampleFeed` nedan för användningsexempel.

### Språk

Feeds created by the syndication framework automatically include the appropriate `<language>` tag (RSS 2.0) or `xml:lang` attribute (Atom). By default, this is `django.utils.translation.get_language()`. You can change it by setting the `language` class attribute.

### URL:er

Metoden/attributet `link` kan returnera antingen en absolut sökväg (t.ex. `"/blog/"`) eller en URL med den fullständigt kvalificerade domänen och protokollet (t.ex. `"https://www.example.com/blog/"`). Om `link` inte returnerar domänen kommer syndikeringsramverket att infoga domänen för den aktuella webbplatsen, enligt din `SITE_ID setting`.

Atom-flöden kräver en `<link rel="self">` som definierar flödets aktuella plats. Syndikeringsramverket fyller i detta automatiskt, med hjälp av domänen för den aktuella webbplatsen enligt inställningen `SITE_ID`.

### Publicera Atom- och RSS-flöden parallellt

Vissa utvecklare vill göra både Atom och RSS-versioner av sina flöden tillgängliga. För att göra det kan du skapa en underklass av din `Feed`-klass och ställa in `feed_type` till något annat. Uppdatera sedan din URLconf för att lägga till de extra versionerna.

Här är ett fullständigt exempel:

    from django.contrib.syndication.views import Feed
    from policebeat.models import NewsItem
    from django.utils.feedgenerator import Atom1Feed

    class RssSiteNewsFeed(Feed):
        title = "Police beat site news"
        link = "/sitenews/"
        description = "Updates on changes and additions to police beat central."

        def items(self):
            return NewsItem.objects.order_by("-pub_date")[:5]

    class AtomSiteNewsFeed(RssSiteNewsFeed):
        feed_type = Atom1Feed
        subtitle = RssSiteNewsFeed.description

Observera

I det här exemplet använder RSS-flödet en ”beskrivning” medan Atom-flödet använder en ”undertitel”. Det beror på att Atom-flöden inte tillhandahåller en ”beskrivning” på flödesnivå, men de * tillhandahåller * en ”undertitel”

Om du tillhandahåller en `description` i din `Feed`-klass, kommer Django inte automatiskt att lägga in det i `undertitel`-elementet, eftersom en undertitel och beskrivning inte nödvändigtvis är samma sak. Istället bör du definiera ett `undertitel`-attribut.

I exemplet ovan ställer vi in Atom-flödets `undertitel` till RSS-flödets `beskrivning`, eftersom den redan är ganska kort.

Och den medföljande URLconf:

    from django.urls import path
    from myproject.feeds import AtomSiteNewsFeed, RssSiteNewsFeed

    urlpatterns = [
        # ...
        path("sitenews/rss/", RssSiteNewsFeed()),
        path("sitenews/atom/", AtomSiteNewsFeed()),
        # ...
    ]

### klassreferens för `Feed`

class views.Feed

Detta exempel illustrerar alla möjliga attribut och metoder för en `Feed` class:

    from django.contrib.syndication.views import Feed
    from django.utils import feedgenerator

    class ExampleFeed(Feed):
        # FEED TYPE -- Optional. This should be a class that subclasses
        # django.utils.feedgenerator.SyndicationFeed. This designates
        # which type of feed this should be: RSS 2.0, Atom 1.0, etc. If
        # you don't specify feed_type, your feed will be RSS 2.0. This
        # should be a class, not an instance of the class.

        feed_type = feedgenerator.Rss201rev2Feed

        # TEMPLATE NAMES -- Optional. These should be strings
        # representing names of Django templates that the system should
        # use in rendering the title and description of your feed items.
        # Both are optional. If a template is not specified, the
        # item_title() or item_description() methods are used instead.

        title_template = None
        description_template = None

        # LANGUAGE -- Optional. This should be a string specifying a language
        # code. Defaults to django.utils.translation.get_language().
        language = "de"

        # TITLE -- One of the following three is required. The framework
        # looks for them in this order.

        def title(self, obj):
            """
            Takes the object returned by get_object() and returns the
            feed's title as a normal Python string.
            """

        def title(self):
            """
            Returns the feed's title as a normal Python string.
            """

        title = "foo"  # Hard-coded title.

        # LINK -- One of the following three is required. The framework
        # looks for them in this order.

        def link(self, obj):
            """
            # Takes the object returned by get_object() and returns the URL
            # of the HTML version of the feed as a normal Python string.
            """

        def link(self):
            """
            Returns the URL of the HTML version of the feed as a normal Python
            string.
            """

        link = "/blog/"  # Hard-coded URL.

        # FEED_URL -- One of the following three is optional. The framework
        # looks for them in this order.

        def feed_url(self, obj):
            """
            # Takes the object returned by get_object() and returns the feed's
            # own URL as a normal Python string.
            """

        def feed_url(self):
            """
            Returns the feed's own URL as a normal Python string.
            """

        feed_url = "/blog/rss/"  # Hard-coded URL.

        # GUID -- One of the following three is optional. The framework looks
        # for them in this order. This property is only used for Atom feeds
        # (where it is the feed-level ID element). If not provided, the feed
        # link is used as the ID.

        def feed_guid(self, obj):
            """
            Takes the object returned by get_object() and returns the globally
            unique ID for the feed as a normal Python string.
            """

        def feed_guid(self):
            """
            Returns the feed's globally unique ID as a normal Python string.
            """

        feed_guid = "/foo/bar/1234"  # Hard-coded guid.

        # DESCRIPTION -- One of the following three is required. The framework
        # looks for them in this order.

        def description(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            description as a normal Python string.
            """

        def description(self):
            """
            Returns the feed's description as a normal Python string.
            """

        description = "Foo bar baz."  # Hard-coded description.

        # AUTHOR NAME --One of the following three is optional. The framework
        # looks for them in this order.

        def author_name(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            author's name as a normal Python string.
            """

        def author_name(self):
            """
            Returns the feed's author's name as a normal Python string.
            """

        author_name = "Sally Smith"  # Hard-coded author name.

        # AUTHOR EMAIL --One of the following three is optional. The framework
        # looks for them in this order.

        def author_email(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            author's email as a normal Python string.
            """

        def author_email(self):
            """
            Returns the feed's author's email as a normal Python string.
            """

        author_email = "test@example.com"  # Hard-coded author email.

        # AUTHOR LINK --One of the following three is optional. The framework
        # looks for them in this order. In each case, the URL should include
        # the scheme (such as "https://") and domain name.

        def author_link(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            author's URL as a normal Python string.
            """

        def author_link(self):
            """
            Returns the feed's author's URL as a normal Python string.
            """

        author_link = "https://www.example.com/"  # Hard-coded author URL.

        # CATEGORIES -- One of the following three is optional. The framework
        # looks for them in this order. In each case, the method/attribute
        # should return an iterable object that returns strings.

        def categories(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            categories as iterable over strings.
            """

        def categories(self):
            """
            Returns the feed's categories as iterable over strings.
            """

        categories = ["python", "django"]  # Hard-coded list of categories.

        # COPYRIGHT NOTICE -- One of the following three is optional. The
        # framework looks for them in this order.

        def feed_copyright(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            copyright notice as a normal Python string.
            """

        def feed_copyright(self):
            """
            Returns the feed's copyright notice as a normal Python string.
            """

        feed_copyright = "Copyright (c) 2007, Sally Smith"  # Hard-coded copyright notice.

        # TTL -- One of the following three is optional. The framework looks
        # for them in this order. Ignored for Atom feeds.

        def ttl(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            TTL (Time To Live) as a normal Python string.
            """

        def ttl(self):
            """
            Returns the feed's TTL as a normal Python string.
            """

        ttl = 600  # Hard-coded Time To Live.

        # STYLESHEETS -- Optional. To set, provide one of the following three.
        # The framework looks for them in this order.

        def stylesheets(self, obj):
            """
            Takes the object returned by get_object() and returns the feed's
            stylesheets (as URL strings or as Stylesheet instances).
            """

        def stylesheets(self):
            """
            Returns the feed's stylesheets (as URL strings or Stylesheet
            instances).
            """

        # Hardcoded stylesheets.
        stylesheets = ["/stylesheet1.xsl", "stylesheet2.xsl"]

        # ITEMS -- One of the following three is required. The framework looks
        # for them in this order.

        def items(self, obj):
            """
            Takes the object returned by get_object() and returns a list of
            items to publish in this feed.
            """

        def items(self):
            """
            Returns a list of items to publish in this feed.
            """

        items = ["Item 1", "Item 2"]  # Hard-coded items.

        # GET_OBJECT -- This is required for feeds that publish different data
        # for different URL parameters. (See "A complex example" above.)

        def get_object(self, request, *args, **kwargs):
            """
            Takes the current request and the arguments from the URL, and
            returns an object represented by this feed. Raises
            django.core.exceptions.ObjectDoesNotExist on error.
            """

        # ITEM TITLE AND DESCRIPTION -- If title_template or
        # description_template are not defined, these are used instead. Both are
        # optional, by default they will use the string representation of the
        # item.

        def item_title(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            title as a normal Python string.
            """

        def item_title(self):
            """
            Returns the title for every item in the feed.
            """

        item_title = "Breaking News: Nothing Happening"  # Hard-coded title.

        def item_description(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            description as a normal Python string.
            """

        def item_description(self):
            """
            Returns the description for every item in the feed.
            """

        item_description = "A description of the item."  # Hard-coded description.

        def get_context_data(self, **kwargs):
            """
            Returns a dictionary to use as extra context if either
            description_template or item_template are used.

            Default implementation preserves the old behavior
            of using {'obj': item, 'site': current_site} as the context.
            """

        # ITEM LINK -- One of these three is required. The framework looks for
        # them in this order.

        # First, the framework tries the two methods below, in
        # order. Failing that, it falls back to the get_absolute_url()
        # method on each item returned by items().

        def item_link(self, item):
            """
            Takes an item, as returned by items(), and returns the item's URL.
            """

        def item_link(self):
            """
            Returns the URL for every item in the feed.
            """

        # ITEM_GUID -- The following method is optional. If not provided, the
        # item's link is used by default.

        def item_guid(self, obj):
            """
            Takes an item, as return by items(), and returns the item's ID.
            """

        # ITEM_GUID_IS_PERMALINK -- The following method is optional. If
        # provided, it sets the 'isPermaLink' attribute of an item's
        # GUID element. This method is used only when 'item_guid' is
        # specified.

        def item_guid_is_permalink(self, obj):
            """
            Takes an item, as returned by items(), and returns a boolean.
            """

        item_guid_is_permalink = False  # Hardcoded value

        # ITEM AUTHOR NAME -- One of the following three is optional. The
        # framework looks for them in this order.

        def item_author_name(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            author's name as a normal Python string.
            """

        def item_author_name(self):
            """
            Returns the author name for every item in the feed.
            """

        item_author_name = "Sally Smith"  # Hard-coded author name.

        # ITEM AUTHOR EMAIL --One of the following three is optional. The
        # framework looks for them in this order.
        #
        # If you specify this, you must specify item_author_name.

        def item_author_email(self, obj):
            """
            Takes an item, as returned by items(), and returns the item's
            author's email as a normal Python string.
            """

        def item_author_email(self):
            """
            Returns the author email for every item in the feed.
            """

        item_author_email = "test@example.com"  # Hard-coded author email.

        # ITEM AUTHOR LINK -- One of the following three is optional. The
        # framework looks for them in this order. In each case, the URL should
        # include the scheme (such as "https://") and domain name.
        #
        # If you specify this, you must specify item_author_name.

        def item_author_link(self, obj):
            """
            Takes an item, as returned by items(), and returns the item's
            author's URL as a normal Python string.
            """

        def item_author_link(self):
            """
            Returns the author URL for every item in the feed.
            """

        item_author_link = "https://www.example.com/"  # Hard-coded author URL.

        # ITEM ENCLOSURES -- One of the following three is optional. The
        # framework looks for them in this order. If one of them is defined,
        # ``item_enclosure_url``, ``item_enclosure_length``, and
        # ``item_enclosure_mime_type`` will have no effect.

        def item_enclosures(self, item):
            """
            Takes an item, as returned by items(), and returns a list of
            ``django.utils.feedgenerator.Enclosure`` objects.
            """

        def item_enclosures(self):
            """
            Returns the ``django.utils.feedgenerator.Enclosure`` list for every
            item in the feed.
            """

        item_enclosures = []  # Hard-coded enclosure list

        # ITEM ENCLOSURE URL -- One of these three is required if you're
        # publishing enclosures and you're not using ``item_enclosures``. The
        # framework looks for them in this order.

        def item_enclosure_url(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            enclosure URL.
            """

        def item_enclosure_url(self):
            """
            Returns the enclosure URL for every item in the feed.
            """

        item_enclosure_url = "/foo/bar.mp3"  # Hard-coded enclosure link.

        # ITEM ENCLOSURE LENGTH -- One of these three is required if you're
        # publishing enclosures and you're not using ``item_enclosures``. The
        # framework looks for them in this order. In each case, the returned
        # value should be either an integer, or a string representation of the
        # integer, in bytes.

        def item_enclosure_length(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            enclosure length.
            """

        def item_enclosure_length(self):
            """
            Returns the enclosure length for every item in the feed.
            """

        item_enclosure_length = 32000  # Hard-coded enclosure length.

        # ITEM ENCLOSURE MIME TYPE -- One of these three is required if you're
        # publishing enclosures and you're not using ``item_enclosures``. The
        # framework looks for them in this order.

        def item_enclosure_mime_type(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            enclosure MIME type.
            """

        def item_enclosure_mime_type(self):
            """
            Returns the enclosure MIME type for every item in the feed.
            """

        item_enclosure_mime_type = "audio/mpeg"  # Hard-coded enclosure MIME type.

        # ITEM PUBDATE -- It's optional to use one of these three. This is a
        # hook that specifies how to get the pubdate for a given item.
        # In each case, the method/attribute should return a Python
        # datetime.datetime object.

        def item_pubdate(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            pubdate.
            """

        def item_pubdate(self):
            """
            Returns the pubdate for every item in the feed.
            """

        item_pubdate = datetime.datetime(2005, 5, 3)  # Hard-coded pubdate.

        # ITEM UPDATED -- It's optional to use one of these three. This is a
        # hook that specifies how to get the updateddate for a given item.
        # In each case, the method/attribute should return a Python
        # datetime.datetime object.

        def item_updateddate(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            updateddate.
            """

        def item_updateddate(self):
            """
            Returns the updateddate for every item in the feed.
            """

        item_updateddate = datetime.datetime(2005, 5, 3)  # Hard-coded updateddate.

        # ITEM CATEGORIES -- It's optional to use one of these three. This is
        # a hook that specifies how to get the list of categories for a given
        # item. In each case, the method/attribute should return an iterable
        # object that returns strings.

        def item_categories(self, item):
            """
            Takes an item, as returned by items(), and returns the item's
            categories.
            """

        def item_categories(self):
            """
            Returns the categories for every item in the feed.
            """

        item_categories = ["python", "django"]  # Hard-coded categories.

        # ITEM COPYRIGHT NOTICE (only applicable to Atom feeds) -- One of the
        # following three is optional. The framework looks for them in this
        # order.

        def item_copyright(self, obj):
            """
            Takes an item, as returned by items(), and returns the item's
            copyright notice as a normal Python string.
            """

        def item_copyright(self):
            """
            Returns the copyright notice for every item in the feed.
            """

        item_copyright = "Copyright (c) 2007, Sally Smith"  # Hard-coded copyright notice.

        # ITEM COMMENTS URL -- It's optional to use one of these three. This is
        # a hook that specifies how to get the URL of a page for comments for a
        # given item.

        def item_comments(self, obj):
            """
            Takes an item, as returned by items(), and returns the item's
            comments URL as a normal Python string.
            """

        def item_comments(self):
            """
            Returns the comments URL for every item in the feed.
            """

        item_comments = "https://www.example.com/comments"  # Hard-coded comments URL

## Ramverket på låg nivå

Bakom kulisserna använder RSS-ramverket på hög nivå ett ramverk på lägre nivå för att generera flödes XML. Detta ramverk finns i en enda modul: django/utils/feedgenerator.py.

Du använder detta ramverk på egen hand, för feedgenerering på lägre nivå. Du kan också skapa anpassade subklasser för flödesgeneratorer för användning med alternativet `feed_type` `Feed`.

### klasserna `SyndicationFeed`

Modulen `feedgenerator` innehåller en basklass:

- `django.utils.feedgenerator.SyndicationFeed`

och flera underklasser:

- `django.utils.feedgenerator.RssUserland091Feed`

- `django.utils.feedgenerator.Rss201rev2Feed`

- `django.utils.feedgenerator.Atom1Feed`

Var och en av dessa tre klasser vet hur man renderar en viss typ av feed som XML. De delar detta gränssnitt:

`SyndicationFeed.__init__()`

  Initiera flödet med den angivna ordlistan med metadata, som gäller för hela flödet. Obligatoriska nyckelordsargument är:

  - `title`

  - `länk`

  - `Beskrivning`

  Det finns också en massa andra valfria nyckelord:

  - `språk`

  - författarens e-postadress

  - `författarens_namn`

  - `författare_länk`

  - `undertitel`

  - `kategorier`

  - `feed_url`

  - `feed_copyright`

  - `feed_guid`

  - `ttl`

  - `stylesheets`

  Eventuella extra nyckelordsargument som du skickar till `__init__` kommer att lagras i `self.feed` för användning med custom feed generators.

  Alla parametrar ska vara strängar, utom två:

  - `categories` ska vara en sekvens av strängar.

  - `stylesheets` ska vara en sekvens av antingen strängar eller `Stylesheet`-instanser.

  Tänk på att vissa kontrolltecken inte är tillåtna <https://www.w3.org/International/questions/qa-controls>`_ i XML-dokument. Om ditt innehåll har några av dem kan du stöta på ett `ValueError` när du producerar flödet.

`SyndicationFeed.add_item()`

  Lägg till ett objekt i flödet med de angivna parametrarna.

  Obligatoriska nyckelordsargument är:

  - `title`

  - `länk`

  - `Beskrivning`

  Valfria nyckelordsargument är:

  - författarens e-postadress

  - `författarens_namn`

  - `författare_länk`

  - `publiceringsdatum`

  - `kommentarer`

  - `unique_id`

  - ”Inneslutningar

  - `kategorier`

  - `objekt_copyright`

  - `ttl`

  - `uppdaterad uppdatering`

  Extra nyckelordsargument kommer att lagras för anpassade fodergeneratorer.

  Alla parametrar, om de anges, ska vara strängar, utom:

  - `pubdate` bör vara ett Python `datetime`-objekt.

  - `updateddate` bör vara ett Python `datetime`-objekt.

  - `enclosures` ska vara en lista med `django.utils.feedgenerator.Enclosure`-instanser.

  - `categories` ska vara en sekvens av strängar.

`SyndicationFeed.write()`

  Matar ut flödet i den angivna kodningen till outfile, som är ett filliknande objekt.

`SyndicationFeed.writeString()`

  Returnerar matningen som en sträng i den angivna kodningen.

Till exempel:, för att skapa en Atom 1.0-feed och skriva ut den till standardutmatningen:

    >>> from django.utils import feedgenerator
    >>> from datetime import datetime
    >>> f = feedgenerator.Atom1Feed(
    ...     title="My Blog",
    ...     link="https://www.example.com/",
    ...     description="In which I write about what I ate today.",
    ...     language="en",
    ...     author_name="Myself",
    ...     feed_url="https://example.com/atom.xml",
    ... )
    >>> f.add_item(
    ...     title="Hot dog today",
    ...     link="https://www.example.com/entries/1/",
    ...     pubdate=datetime.now(),
    ...     description="<p>Today I had a Vienna Beef hot dog. It was pink, plump and perfect.</p>",
    ... )
    >>> print(f.writeString("UTF-8"))
    <?xml version="1.0" encoding="UTF-8"?>
    <feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
    ...
    </feed>

### Anpassade fodergeneratorer

Om du behöver producera ett anpassat feedformat har du ett par alternativ.

Om flödesformatet är helt anpassat vill du subklassa `SyndicationFeed` och helt ersätta metoderna `write()` och `writeString()`.

Men om flödesformatet är en spin-off av RSS eller Atom (dvs. GeoRSS, Apples iTunes podcastformat, etc.), har du ett bättre val. Dessa typer av feeds lägger vanligtvis till extra element och/eller attribut till det underliggande formatet, och det finns en uppsättning metoder som `SyndicationFeed` anropar för att få dessa extra attribut. Således kan du underordna den lämpliga feedgeneratorklassen (`Atom1Feed` eller `Rss201rev2Feed`) och utöka dessa återuppringningar. De är följande:

`SyndicationFeed.root_attributes(self)`

  Returnerar ett `dict` av attribut att lägga till i rotfeed-elementet (`feed`/`channel`).

`SyndicationFeed.add_root_elements(self, handler)`

  Callback för att lägga till element inuti rotfeed-elementet (`feed`/`channel`). `handler` är en `XMLGenerator` från Pythons inbyggda SAX-bibliotek; du kommer att anropa metoder på den för att lägga till XML-dokumentet i processen.

`SyndicationFeed.item_attributes(self, item)`

  Returnerar ett `dict` med attribut som ska läggas till i varje item (`item`/`entry`)-element. Argumentet, `item`, är en ordbok med alla data som skickas till `SyndicationFeed.add_item()`.

`SyndicationFeed.add_item_elements(self, handler, item)`

  Callback för att lägga till element till varje objekt (`item`/entry`) element. `handler` och `item` är som ovan.

Varning

Om du åsidosätter någon av dessa metoder ska du se till att anropa metoderna i superklassen eftersom de lägger till de element som krävs för varje feedformat.

Du kan till exempel börja implementera en iTunes RSS-flödesgenerator så här:

    class iTunesFeed(Rss201rev2Feed):
        def root_attributes(self):
            attrs = super().root_attributes()
            attrs["xmlns:itunes"] = "http://www.itunes.com/dtds/podcast-1.0.dtd"
            return attrs

        def add_root_elements(self, handler):
            super().add_root_elements(handler)
            handler.addQuickElement("itunes:explicit", "clean")

Det finns mycket mer arbete att göra för en komplett anpassad foderklass, men ovanstående exempel bör visa den grundläggande idén.

### Mata in formatmallar

Om du vill att ditt RSS-flöde ska visas snyggt i en webbläsare måste du tillhandahålla stylinginformation för XML-filen, vanligtvis i XSLT- eller CSS-format.

Du kan lägga till detta i ditt RSS-flöde genom att ställa in attributet `stylesheets` på feed-klassen.

Detta kan vara en hårdkodad URL:

    from django.contrib.syndication.views import Feed

    class FeedWithHardcodedStylesheet(Feed):
        stylesheets = [
            "https://example.com/rss_stylesheet.xslt",
        ]

Du kan också använda Djangos system för statiska filer:

    from django.contrib.syndication.views import Feed
    from django.templatetags.static import static

    class FeedWithStaticFileStylesheet(Feed):
        stylesheets = [
            static("rss_styles.xslt"),
        ]

Ett annat alternativ är att ha en vy i ditt projekt som renderar XSLT-dokumentet. Du kan sedan länka den så här:

    from django.contrib.syndication.views import Feed
    from django.urls import reverse_lazy

    class FeedWithStylesheetView(Feed):
        stylesheets = [
            reverse_lazy("your-custom-view-name"),
        ]

Django kommer normalt att försöka gissa MIME-typen för den angivna URL:en baserat på dess tillägg, men om det misslyckas kan du ange den med hjälp av `Stylesheet` class:

    from django.contrib.syndication.views import Feed
    from django.utils.feedgenerator import Stylesheet

    class FeedWithHardcodedStylesheet(Feed):
        stylesheets = [
            Stylesheet("https://example.com/rss_stylesheet", mimetype="text/xsl"),
        ]

På samma sätt, om du vill använda ett annat `media`-attribut än `screen` (Djangos standard), kan du använda klassen `Stylesheet` igen:

    from django.contrib.syndication.views import Feed
    from django.utils.feedgenerator import Stylesheet

    class FeedWithHardcodedStylesheet(Feed):
        stylesheets = [
            Stylesheet("https://example.com/rss_stylesheet.xslt", media="print"),
        ]

Alla dessa alternativ kan kombineras när du använder flera formatmallar:

    from django.contrib.syndication.views import Feed
    from django.utils.feedgenerator import Stylesheet

    class MultiStylesheetFeed(Feed):
        stylesheets = [
            "/stylesheet1.xsl",
            Stylesheet("/stylesheet2.xsl"),
        ]