# Documentation Django 5.2.8

# L’infrastructure de syndication par flux

Django est livré avec une infrastructure de génération de flux de syndication de haut niveau pour la création de flux RSS et Atom.

Pour créer un flux de syndication, tout ce que vous avez à faire est d’écrire une courte classe Python. On peut créer autant de flux que nécessaire.

Django contient également une API de génération de flux de plus bas niveau. Celle-ci peut être utilisée pour générer des flux en dehors du contexte web ou d’une autre manière nécessitant l’accès à un plus bas niveau.

## L’infrastructure de haut niveau

### Aperçu

L’infrastructure de génération de flux de syndication de haut niveau est fournie par la classe `Feed`. Pour créer un flux, écrivez une classe `Feed` et faites pointer votre configuration d’URL vers cette classe.

### Classes `Feed` (flux)

Une classe `Feed` est une classe Python qui représente un flux de syndication. Un flux peut être simple (par exemple un flux d’actualités d’un site ou un flux élémentaire affichant les derniers articles d’un blog) ou plus complexe (par exemple un flux affichant tous les articles de blog d’une certaine catégorie, celle-ci étant variable).

Les classes de flux héritent de `django.contrib.syndication.views.Feed`. Elles peuvent résider n’importe où dans votre code source.

Les instances de classes `Feed` sont des vues qui peuvent être utilisées dans la configuration d’URL.

### Un exemple simple

Cet exemple simple, tiré d’un hypothétique site d’actualités de bévues policières, décrit un flux des cinq dernières actualités :

    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])

Pour faire le lien entre une URL et ce flux, placez une instance de l’objet `Feed` dans la configuration d’URL. Par exemple :

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

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

Remarque :

- La classe de flux hérite de `django.contrib.syndication.views.Feed`.

- `title`, `link` et `description` correspondent respectivement aux éléments `<title>`, `<link>` et `<description>` du standard RSS.

- `items()` est une méthode qui renvoie une liste d’objets qui devraient être inclus dans l’alimentation du flux en tant qu’éléments `<item>`. Bien que cet exemple retourne des objets `NewsItem` à l’aide de l’API QuerySet de Django, `items()` n’est pas tenu de renvoyer des instances de modèles. Même si vous obtenez quelques fonctionnalités supplémentaires en utilisant des modèles de Django, `items()` peut renvoyer n’importe quel type d’objet souhaité.

- Si vous créez un flux Atom, plutôt qu’un flux RSS, définissez l’attribut `subtitle` la place de l’attribut `description`. Voir Publication de flux Atom et RSS en tandem, plus loin, pour un exemple.

Il reste une chose à faire. Dans un flux RSS, chaque `<item>` a un `<title>`, `<Link>` et `<description>`. Nous devons dire au framework ce qu’il faut mettre dans ces éléments.

- Pour le contenu de `<title>` et `<description>`, Django essaie d’appeler les méthodes `item_title()` et `item_description()` de la classe `Feed`. Un seul paramètre leur est passé, `item`, qui est l’objet lui-même. Ces méthodes sont facultatives ; par défaut, la représentation textuelle de l’objet est utilisée pour les deux.

  Si vous voulez utiliser une mise en forme spéciale pour le titre ou la description, les gabarits de Django peuvent être utilisés à la place de ces méthodes. Les chemins de ces gabarits peuvent être spécifiés par les attributs `title_template` et `description_template` de la classe `Feed`. Les gabarits sont utilisés pour chaque élément et deux variables de contexte leurs sont passées :

  - `{{ Obj }}` - L’objet courant (l’un des objets que vous retournez dans `items()`).

  - `{{ site }}` – Un objet `django.contrib.sites.models.Site` représentant le site actuel. C’est utile pour `{{ site.domain }}` ou `{{ site.name }}`. Si vous n’avez pas installé le framework de sites de Django, il s’agira d’un objet `RequestSite`. Voir la documentation du framework de sites pour plus d’information.

  Voir Un exemple complexe ci-dessous pour l’utilisation d’un gabarit pour la description.

  Feed.get_context_data(**kwargs)

    Il est aussi un moyen de transmettre des informations supplémentaires au gabarit, en plus du titre et la description, si vous avez besoin de fournir plus que ces deux variables. Vous pouvez fournir votre propre implémentation de la méthode `get_context_data` dans votre sous-classe `Feed`. Par exemple

        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

  Et le gabarit :

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

  Cette méthode sera appelée une fois pour chaque élément de la liste renvoyée par `items()` avec les paramètres nommés suivants:

  - `item`: l’élément en cours. Pour des raisons de compatibilité descendante, le nom de cette variable de contexte est `{{ obj }}`.

  - `obj`: l’objet renvoyé par `get_object()`. Par défaut, ce paramètre n’est pas fourni dans les gabarits pour éviter toute confusion avec `{{ obj }}` (voir ci-dessus), mais vous pouvez l’utiliser dans votre implémentation de `get_context_data()`.

  - `site`: le site actuel comme décrit ci-dessus.

  - `request`: la requête en cours.

  Le comportement de `get_context_data()` imite celui des vues génériques, vous êtes censé appeler `super()` pour obtenir les données de contexte de la classe parente, puis ajouter vos données et renvoyer le dictionnaire modifié.

- Pour définir le contenu de `<link>`, vous avez deux options. Pour chaque élément dans `items()`, Django essaie d’abord d’appeler la méthode `item_link()` de la classe `Feed`. De manière semblable aux attributs `title` et `description`, la méthode reçoit un seul paramètre, `item`. Si cette méthode n’existe pas, Django essaie d’appeler une méthode `get_absolute_url()` de cet objet. Aussi bien `get_absolute_url()` que `item_link()` doivent renvoyer l’URl de l’élément sous forme d’une chaîne Python normale. Comme avec `get_absolute_url()`, le résultat de `item_link()` sera directement inclus dans l’URL, vous êtes donc responsable d’effectuer toute opération nécessaire (échappement, conversion en ASCII) dans la méthode elle-même.

### Un exemple complexe

L’application gère aussi des flux plus complexes, via des paramètres.

Par exemple, un site web pourrait offrir un flux RSS des crimes récents pour chaque section de police de la ville. Il serait stupide de créer une classe `Feed` séparée pour chaque section de police ; cela violerait le principe DRY et lierait les données à la logique de programmation. Au lieu de cela, le système de syndication permet d’accéder aux paramètres transmis par l’intermédiaire de la configuration d’URL afin que les flux puissent produire des éléments en fonction d’informations présentes dans l’URL du flux.

Le flux du secteur de police pourrait être accessible via des URL comme :

- `/beats/613/rss/` – Renvoie les crimes récents pour le secteur 613.

- `/beats/1424/rss/` – Renvoie les crimes récents pour le secteur 1424.

Elles peuvent correspondre à une ligne de configuration d’URL telle que :

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

Comme pour une vue, les paramètres dans l’URL sont transmis à la méthode `get_object()` en même temps que l’objet requête.

Voici le code correspondant à ces flux par secteur :

    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]

Pour générer les balises `<title>`, `<link>` et `<description>` du flux, Django utilise les méthodes `title()`, `link()` et `description()`. Dans l’exemple précédent, il s’agissait d’attributs de classe textuels, mais cet exemple illustre qu’il peut aussi bien s’agir de chaînes que de méthodes. Pour chacune de ces valeurs `title`, `link` et `description`, Django suit cet algorithme :

- Il commence par essayer d’appeler une méthode en transmettant le paramètre `obj`, où `obj` est l’objet renvoyé par `get_object()`.

- Si cela échoue, il essaie d’appeler une méthode sans paramètre.

- En dernier recours, il utilise l’attribut de classe.

Notez également que `items()` utilise le même algorithme, il essaie d’abord `items(obj)`, puis `items()`, et pour terminer un attribut de classe `items` (qui doit être une liste).

Nous utilisons un gabarit pour les descriptions des éléments. Il peut être aussi minimal que ceci :

    {{ obj.description }}

Cependant, vous êtes libre d’ajouter de la mise en forme selon vos besoins.

La classe `ExampleFeed` plus bas dans ce document apporte une documentation complète sur les méthodes et attributs des classes `Feed`.

### Indication du type de flux

Par défaut, les flux produits par cette infrastructure utilisent RSS 2.0.

Pour changer cela, ajoutez un attribut `feed_type` à votre classe `Feed` comme ceci :

    from django.utils.feedgenerator import Atom1Feed

    class MyFeed(Feed):
        feed_type = Atom1Feed

Notez que `feed_type` est défini sur un objet classe, pas une instance.

Les types de flux actuellement disponibles sont :

- `django.utils.feedgenerator.Rss201rev2Feed` (RSS 2.01. Valeur par défaut).

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

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

### Annexes

Pour définir des annexes, telles que celles utilisées pour créer des flux « podcast », utilisez le point d’entrée `item_enclosures` ou, dans le cas où vous n’avez qu’une seule annexe par élément, les points d’entrée `item_enclosure_url`, `item_enclosure_length` et `item_enclosure_mime_type`. Voir la classe `ExampleFeed` ci-dessous pour des exemples d’utilisation.

### Langue

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

L’attribut/méthode `link` peut renvoyer soit un chemin absolu (par ex. `"/blog/"`), soit une URL avec domaine pleinement qualifié et protocole (par ex. `"https://www.example.com/blog/"`). Si `link` ne renvoie pas de domaine, l’infrastructure de syndication insère le domaine du site actuel, en fonction du réglage `SITE_ID`.

Les flux Atom exigent un `<link rel="self">` qui définit l’emplacement actuel du flux. L’infrastructure de syndication le remplit automatiquement, en utilisant le domaine du site actuel en fonction du réglage `SITE_ID`.

### Publication de flux Atom et RSS en tandem

Certains développeurs aiment bien rendre disponible à la fois des version Atom et RSS de leurs flux. Pour faire cela, vous pouvez créer une sous-classe de votre classe `Feed` et définir `feed_type` à une autre valeur. Puis mettez à jour votre configuration d’URL pour ajouter les versions supplémentaires.

Voici un exemple complet :

    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

Note

Dans cet exemple, le flux RSS utilise une `description` alors que le flux Atom utilise `subtitle`. C’est dû au fait que les flux Atom n’ont pas de « description » au niveau du flux, mais ils possèdent un champ « subtitle ».

Si vous fournissez une `description` dans votre classe `Feed`, django ne va pas automatiquement déplacer sont contenu dans l’élément `subtitle`, car un sous-titre et une description ne font pas forcément référence à la même chose. Vous devez plutôt définir un attribut `subtitle`.

Dans l’exemple ci-dessus, nous avons défini le champ `subtitle` du flux Atom à partir du contenu `description` du flux RSS, car ce dernier était déjà assez court.

Ainsi que la configuration d’URL qui va avec :

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

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

### Référence de la classe de flux `Feed`

class views.Feed

Cet exemple illustre tous les attributs et méthodes possibles pour une classe `Feed`:

    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

## L’infrastructure de bas niveau

En arrière-plan, l’infrastructure RSS de haut niveau utilise une infrastructure de plus bas niveau pour produire le code XML des flux. Cette infrastructure se trouve dans un module unique : django/utils/feedgenerator.py.

Cette infrastructure peut être utilisée pour générer des flux à un plus bas niveau, mais c’est à vous de vous débrouillez. Il est aussi possible de créer des sous-classes de génération de flux personnalisées exploitables avec l’option `feed_type` de `Feed`.

### Classes `SyndicationFeed`

Le module `feedgenerator` contient une classe de base :

- `django.utils.feedgenerator.SyndicationFeed`

et plusieurs sous-classes :

- `django.utils.feedgenerator.RssUserland091Feed`

- `django.utils.feedgenerator.Rss201rev2Feed`

- `django.utils.feedgenerator.Atom1Feed`

Chacune de ces trois classes sait comment produire un certain type de flux sous forme XML. Elles partagent cette interface :

`SyndicationFeed.__init__()`

  Initialise le flux avec le dictionnaire de métadonnées indiqué, qui s’applique au flux entier. Les paramètres nommés obligatoires sont :

  - `title`

  - `link`

  - `description`

  Il existe également un lot de paramètres nommés facultatifs :

  - `language`

  - `author_email`

  - `author_name`

  - `author_link`

  - `subtitle`

  - `categories`

  - `feed_url`

  - `feed_copyright`

  - `feed_guid`

  - `ttl`

  - `stylesheets`

  Tout paramètre nommé supplémentaire passé à `__init__` est stocké dans `self.feed`, à l’usage de générateurs de flux personnalisés.

  Tous les paramètres doivent être des chaînes, à l’exception de deux :

  - `categories` doit être une liste de chaînes.

  - `stylesheets` doit être une séquence de chaînes ou d’instances `Stylesheet`.

  Prenez garde à certains caractères de contrôle qui ne sont pas autorisés dans les documents XML. Si votre contenu en contient certains, vous pouvez rencontrer une exception `ValueError` lors de la production du flux.

  Changed in Django 5.2:

  Le paramètre `stylesheets` a été ajouté.

`SyndicationFeed.add_item()`

  Ajoute un élément au flux avec les paramètres donnés.

  Les paramètres nommés obligatoires sont :

  - `title`

  - `link`

  - `description`

  Les paramètres nommés facultatifs sont :

  - `author_email`

  - `author_name`

  - `author_link`

  - `pubdate`

  - `comments`

  - `unique_id`

  - `enclosures`

  - `categories`

  - `item_copyright`

  - `ttl`

  - `updateddate`

  Des paramètres nommés supplémentaires sont stockés pour des générateurs de flux personnalisés.

  Tous les paramètres, s’ils sont fournis, doivent être des chaînes, à l’exception de :

  - `pubdate` doit être un objet Python `datetime`.

  - `updateddate` doit être un objet Python `datetime`.

  - `enclosures` doit être une liste d’instances `django.utils.feedgenerator.Enclosure`.

  - `categories` doit être une liste de chaînes.

`SyndicationFeed.write()`

  Produit le flux dans le codage indiqué vers `outfile`, qui est un objet de type fichier.

`SyndicationFeed.writeString()`

  Renvoie le flux sous forme de chaîne dans le codage indiqué.

Par exemple, pour créer un flux Atom 1.0 et l’afficher vers la sortie standard :

    >>> 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>

### Générateurs de flux personnalisés

Si vous avez besoin de produire un format de flux personnalisé, plusieurs options s’offrent à vous.

Si le flux est totalement personnalisé, on peut créer une sous-classe de `SyndicationFeed` et complètement remplacer les méthodes `write()` et `writeString()`.

Cependant, si le format de flux est dérivé de RSS ou d’Atom (par ex. GeoRSS, format podcast iTunes d’Apple, etc.), il existe une meilleure solution. Ces types de flux ajoutent généralement des éléments ou attributs supplémentaires au format dont ils s’inspirent, et il y a quelques méthodes appelées par `SyndicationFeed` pour obtenir ces attributs supplémentaires. Ainsi, vous pouvez hériter de la classe de génération de flux adéquate (`Atom1Feed` ou `Rss201rev2Feed`) et étendre ces points d’entrée. Les voici :

`SyndicationFeed.root_attributes(self)`

  Renvoie un `dict` d’attributs à ajouter à l’élément racine du flux (`feed`/`channel`).

`SyndicationFeed.add_root_elements(self, handler)`

  Point d’entrée pour ajouter des éléments à l’intérieur de l’élément racine du flux (`feed`/`channel`). `handler` est une classe `XMLGenerator` de la bibliothèque SAX intégrée à Python ; ce sont ses méthodes que vous appellerez pour ajouter du contenu au document XML en cours de production.

`SyndicationFeed.item_attributes(self, item)`

  Renvoie un `dict` d’attributs à ajouter à chaque élément (`item`/`entry`). Le paramètre `item` est un dictionnaire de toutes les données transmises à `SyndicationFeed.add_item()`.

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

  Point d’entrée pour ajouter des éléments à chaque élément (`item`/`entry`) du flux. `handler` et `item` sont identiques à ce qui est expliqué ci-dessus.

Avertissement

Si vous surchargez une de ces méthodes, assurez-vous d’appeler les méthodes de la classe parente (super) car celles-ci ajoutent les éléments obligatoires de chaque format de flux.

Par exemple, voici comment l’on pourrait commencer à implémenter un générateur RSS de flux iTunes :

    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")

Il y a encore bien du travail pour arriver à une classe de flux personnalisé complète, mais l’exemple ci-dessus présente l’idée de base.

### Feuilles de style des flux

New in Django 5.2.

Si vous souhaitez que vos flux RSS soient joliment affichés dans les navigateurs, vous pouvez fournir des information de style pour le fichier XML, typiquement en format XSLT ou CSS.

Vous pouvez l’ajouter dans vos flux RSS en définissant l’attribut `stylesheets` de la classe du flux.

Cela peut être une URL fixe :

    from django.contrib.syndication.views import Feed

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

Il est aussi possible d’utiliser le système des fichiers statiques de Django :

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

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

Une autre option est d’avoir une vue de votre projet qui produise le document XSLT. Il est alors possible de la lier comme ceci :

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

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

Django essaie normalement de deviner le type MIME de l’URL donnée selon son extension, mais si cela échoue, vous pouvez le préciser en utilisant la classe `Stylesheet`:

    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"),
        ]

De même, si vous souhaitez utiliser un attribut `media` différent de `screen` (la valeur par défaut de Django), vous pouvez également utiliser la classe `Stylesheet`:

    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"),
        ]

Chacune de ces options peut être combinée lors de l’utilisation de plusieurs feuilles de style :

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

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