Comment utiliser les relations de base de données plusieurs-à-plusieurs avec Flask-SQLAlchemy

Tutoriels

Flask Python

L’auteur a sélectionné le Fonds pour le Logiciel Libre et Open Source pour recevoir un don dans le cadre du programme Écrire pour les Dons.

Introduction

Flask est un framework web Python léger qui fournit des outils et des fonctionnalités utiles pour créer des applications web en langage Python. SQLAlchemy est une boîte à outils SQL qui offre un accès efficace et performant aux bases de données relationnelles. Il propose des moyens d’interagir avec plusieurs moteurs de base de données tels que SQLite, MySQL et PostgreSQL. Il vous donne accès aux fonctionnalités SQL de la base de données. Il vous offre également un Mappage Objet Relationnel (ORM), qui vous permet de réaliser des requêtes et de manipuler des données à l’aide d’objets et de méthodes Python. Flask-SQLAlchemy est une extension Flask qui facilite l’utilisation de SQLAlchemy avec Flask, en vous fournissant des outils et des méthodes pour interagir avec votre base de données dans vos applications Flask via SQLAlchemy.

A many-to-many database relationship is a relationship between two database tables where a record in each table can reference several records in the other table. For example, in a blog, a table for posts can have a many-to-many relationship with a table for storing authors. Each post can have many authors, and each author can write many posts. Therefore, there is a many-to-many relationship between posts and authors. For another example, in a social media application, each post may have many hashtags, and each hashtag may have many posts.

Dans ce tutoriel, vous allez modifier une application construite avec Flask et Flask-SQLAlchemy en ajoutant une relation many-to-many. Vous aurez une relation entre les articles et les tags, où chaque article de blog peut avoir plusieurs tags et chaque tag peut avoir plusieurs articles tagués avec lui.

Bien que vous puissiez suivre ce tutoriel de manière indépendante, il s’agit également d’une continuation du tutoriel Comment utiliser les relations de base de données un à plusieurs avec Flask-SQLAlchemy, dans lequel vous créez une base de données multi-tables avec une relation un à plusieurs entre les articles et les commentaires dans une application de blog.

À la fin du tutoriel, votre application disposera d’une nouvelle fonctionnalité permettant d’ajouter des tags aux articles. Les articles peuvent être tagués avec plusieurs tags, et chaque page de tag affichera tous les articles tagués avec celui-ci.

Prérequis

Un environnement de programmation Python 3 local. Suivez le tutoriel pour votre distribution dans la série Comment installer et configurer un environnement de programmation local pour Python 3. Dans ce tutoriel, nous appellerons notre répertoire de projet flask_app.
Une compréhension des concepts de base de Flask, tels que les routes, les fonctions de vue et les modèles. Si vous n’êtes pas familier avec Flask, consultez Comment créer votre première application Web avec Flask et Python et Comment utiliser les modèles dans une application Flask.
Une compréhension des concepts de base de HTML. Vous pouvez consulter notre série de tutoriels Comment construire un site Web avec HTML pour des connaissances préalables.
(Optionnel) À l’étape 1, vous clonerez l’application de blog sur laquelle vous travaillerez dans ce tutoriel. Cependant, vous pouvez éventuellement suivre le tutoriel Comment utiliser les relations de base de données un à plusieurs avec Flask-SQLAlchemy. Vous pouvez accéder au code final de cette page.

Étape 1 — Configuration de l’application Web

Dans cette étape, vous configurerez l’application de blog pour qu’elle soit prête à être modifiée. Vous passerez également en revue les modèles de base de données Flask-SQLAlchemy et les routes Flask pour comprendre la structure de l’application. Si vous avez suivi le tutoriel dans la section des prérequis et que vous avez toujours le code et l’environnement virtuel sur votre machine locale, vous pouvez passer cette étape.

Pour démontrer l’ajout d’une relation plusieurs-à-plusieurs à une application web Flask avec Flask-SQLAlchemy, vous utiliserez le code de l’application du tutoriel précédent, qui est un système de blog avec la capacité d’ajouter et d’afficher des articles, de commenter des articles, et de lire et supprimer des commentaires.

Clonez le dépôt et renommez-le de flask-slqa-bloggy à flask_app avec la commande suivante:

git clone https://github.com/do-community/flask-slqa-bloggy flask_app

Naviguez vers flask_app:

cd flask_app

Ensuite, créez un nouvel environnement virtuel:

python -m venv env

Activez l’environnement:

source env/bin/activate

Installez Flask et Flask-SQLAlchemy:

pip install Flask Flask-SQLAlchemy

Ensuite, définissez les variables d’environnement suivantes:

export FLASK_APP=app
export FLASK_ENV=development

FLASK_APP indique l’application que vous développez actuellement, qui est app.py dans ce cas. FLASK_ENV spécifie le mode. Vous le définirez sur development pour le mode de développement ; cela vous permettra de déboguer l’application. N’oubliez pas de ne pas utiliser ce mode en environnement de production.

Ensuite, ouvrez l’interpréteur Flask pour créer les tables de la base de données:

flask shell

Ensuite, importez l’objet base de données Flask-SQLAlchemy db, le modèle Post, et le modèle Comment, et créez les tables de la base de données en utilisant la fonction db.create_all():

from app import db, Post, Comment
db.create_all()
exit()

Ensuite, peuplez la base de données en utilisant le programme init_db.py:

python init_db.py

Cela ajoute trois articles et quatre commentaires à la base de données.

Exécutez le serveur de développement:

flask run

Si vous allez dans votre navigateur, l’application sera disponible à l’URL suivante:

http://127.0.0.1:5000/

Vous verrez une page similaire à ce qui suit :

Si vous obtenez une erreur, assurez-vous d’avoir suivi correctement les étapes ci-dessus.

Pour arrêter le serveur de développement, utilisez CTRL + C.

Ensuite, vous passerez par les modèles de base de données Flask-SQLAlchemy pour comprendre les relations actuelles entre les tables. Si vous êtes familier avec le contenu du fichier app.py, vous pouvez passer à l’étape suivante.

Ouvrez le fichier app.py :

nano app.py

Le contenu du fichier est le suivant :

flask_app/app.py

import os
from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy

basedir = os.path.abspath(os.path.dirname(__file__))

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] =\
           'sqlite:///' + os.path.join(basedir, 'database.db')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False


db = SQLAlchemy(app)


class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100))
    content = db.Column(db.Text)
    comments = db.relationship('Comment', backref='post')

    def __repr__(self):
        return f'<Post "{self.title}">'


class Comment(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text)
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'))

    def __repr__(self):
        return f'<Comment "{self.content[:20]}...">'


@app.route('/')
def index():
    posts = Post.query.all()
    return render_template('index.html', posts=posts)


@app.route('/<int:post_id>/', methods=('GET', 'POST'))
def post(post_id):
    post = Post.query.get_or_404(post_id)
    if request.method == 'POST':
        comment = Comment(content=request.form['content'], post=post)
        db.session.add(comment)
        db.session.commit()
        return redirect(url_for('post', post_id=post.id))

    return render_template('post.html', post=post)


@app.route('/comments/')
def comments():
    comments = Comment.query.order_by(Comment.id.desc()).all()
    return render_template('comments.html', comments=comments)


@app.post('/comments/<int:comment_id>/delete')
def delete_comment(comment_id):
    comment = Comment.query.get_or_404(comment_id)
    post_id = comment.post.id
    db.session.delete(comment)
    db.session.commit()
    return redirect(url_for('post', post_id=post_id))

Ici, vous avez deux modèles de base de données représentant deux tables :

Post : qui a une colonne ID, un titre, un contenu et une relation Un-à-Plusieurs avec la table des commentaires.
Commentaire : qui a une colonne ID, une colonne pour le contenu et une colonne post_id pour référencer le message auquel le commentaire appartient.

Sous les modèles, vous avez les itinéraires suivants :

/ : La page d’index, qui affiche tous les messages dans la base de données.
/<int:post_id>/ : La page de message individuelle. Par exemple, le lien http://127.0.0.1:5000/2/ affiche les détails du deuxième message dans la base de données et ses commentaires.
/commentaires/: Une page qui affiche tous les commentaires dans la base de données et des liens vers la publication sur laquelle chaque commentaire a été posté.
/commentaires/<int:commentaire_id>/supprimer: Une route qui supprime un commentaire à travers un bouton Supprimer le commentaire.

Fermez le fichier app.py.

Dans l’étape suivante, vous utiliserez une relation many-to-many pour créer un lien entre deux tables.

Étape 2 — Configuration des modèles de base de données pour une relation many-to-many

Dans cette étape, vous ajouterez un modèle de base de données qui représentera la table des balises. Vous la lierez avec la table des publications existante en utilisant une table d’association, qui est une table qui connecte vos deux tables dans une relation many-to-many. Une relation many-to-many lie deux tables où chaque élément dans une table a de nombreux éléments associés dans l’autre table. Dans la table d’association, chaque publication fera référence à ses balises et chaque balise fera référence aux publications marquées avec elle. Vous insérerez également quelques publications et balises dans votre base de données, imprimerez des publications avec leurs balises, et imprimerez des balises et leurs publications associées.

Disons que vous avez une table simple pour les publications de blog comme suit :

Posts
+----+-----------------------------------+
| id | content                           |
+----+-----------------------------------+
| 1  | A post on life and death          |
| 2  | A post on joy                     |
+----+-----------------------------------+

Et une table pour les balises comme ceci :

Tags
+----+-------+
| id | name  |
+----+-------+
| 1  | life  |
| 2  | death |
| 3  | joy   |
+----+-------+

Supposons que vous vouliez étiqueter Un article sur la vie et la mort avec les balises vie et mort. Vous pouvez le faire en ajoutant une nouvelle ligne dans la table des articles comme ceci:

Posts
+----+-----------------------------------+------+
| id | content                           | tags |
+----+-----------------------------------+------+
| 1  | A post on life and death          | 1, 2 |
| 2  | A post on joy                     |      |
+----+------------------------------------------+

Cette approche ne fonctionne pas, car chaque colonne ne devrait avoir qu’une seule valeur. Si vous avez plusieurs valeurs, les opérations de base telles que l’ajout et la mise à jour des données deviennent fastidieuses et lentes. Au lieu de cela, il devrait y avoir une troisième table qui fait référence aux clés primaires des tables associées, cette table est souvent appelée une table d’association ou une table de jointure, et elle stocke les identifiants de chaque élément de chaque table.

Voici un exemple de table d’association qui lie les articles aux balises:

post_tag
+----+---------+-------------+
| id | post_id | tag_id      |
+----+---------+-------------+
| 1  | 1       | 1           |
| 2  | 1       | 2           |
+----+---------+-------------+

Dans la première ligne, l’article avec l’ID 1 (c’est-à-dire Un article sur la vie et la mort) est lié à la balise avec l’ID 1 (vie). Dans la deuxième ligne, le même article est également lié à la balise avec l’ID 2 (mort). Cela signifie que l’article est étiqueté avec à la fois les balises vie et mort. De même, vous pouvez étiqueter chaque article avec plusieurs balises.

Maintenant, vous allez modifier le fichier app.py pour ajouter un nouveau modèle de base de données qui représente la table que vous utiliserez pour stocker les balises. Vous ajouterez également une table d’association appelée post_tag qui relie les articles aux balises.

Tout d’abord, ouvrez app.py pour établir une relation entre les articles et les balises:

nano app.py

Ajoutez une table post_tag et un modèle Tag sous l’objet db et au-dessus du modèle Post, puis ajoutez une pseudo-colonne de relation tags au modèle Post pour pouvoir accéder aux tags d’un article via post.tags et accéder aux articles d’un tag via tag.posts:

flask_app/app.py


# ...

db = SQLAlchemy(app)


post_tag = db.Table('post_tag',
                    db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
                    db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
                    )


class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))

    def __repr__(self):
        return f'<Tag "{self.name}">' 



class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100))
    content = db.Column(db.Text)
    comments = db.relationship('Comment', backref='post')
    tags = db.relationship('Tag', secondary=post_tag, backref='posts')

    def __repr__(self):
        return f'<Post "{self.title}">'

Enregistrez et fermez le fichier.

Ici, vous utilisez la fonction db.Table() pour créer une table avec deux colonnes. Pour les tables d’association, la meilleure pratique est d’utiliser une table au lieu d’un modèle de base de données.

La table post_tag a deux colonnes représentant deux clés étrangères, qui sont des clés utilisées pour référencer les colonnes de clé primaire dans une autre table:

post_id: Une clé étrangère de type entier représentant l’ID de l’article et faisant référence à la colonne ID dans la table post.
tag_id: Une clé étrangère de type entier représentant l’ID du tag et faisant référence à la colonne ID dans la table tag.

Ces clés établissent les relations entre les tables.

Sous la table post_tag, vous créez un modèle Tag, qui représente la table dans laquelle vous stockerez vos tags. Cette table de tags a deux colonnes:

id: L’ID du tag.
name: Le nom du tag.

Vous utilisez le nom du tag dans la méthode spéciale __repr__() pour donner à chaque objet tag une représentation de chaîne claire à des fins de débogage.

Vous ajoutez une variable de classe tags au modèle Post. Vous utilisez la méthode db.relationship(), en lui passant le nom du modèle de tags (Tag dans ce cas).

Vous passez la table d’association post_tag au paramètre secondary pour établir une relation de plusieurs à plusieurs entre les articles et les tags.

Vous utilisez le paramètre backref pour ajouter une référence arrière qui se comporte comme une colonne au modèle Tag. De cette manière, vous pouvez accéder aux articles du tag via tag.posts et aux tags d’un article via post.tags. Vous verrez un exemple illustrant ceci plus tard.

Ensuite, modifiez le programme Python init_db.py pour modifier la base de données en ajoutant la table d’association post_tag et la table des tags qui sera basée sur le modèle Tag:

nano init_db.py

Modifiez le fichier pour qu’il ressemble à ceci:

flask_app/init_db.py

from app import db, Post, Comment, Tag

db.drop_all()
db.create_all()

post1 = Post(title='Post The First', content='Content for the first post')
post2 = Post(title='Post The Second', content='Content for the Second post')
post3 = Post(title='Post The Third', content='Content for the third post')

comment1 = Comment(content='Comment for the first post', post=post1)
comment2 = Comment(content='Comment for the second post', post=post2)
comment3 = Comment(content='Another comment for the second post', post_id=2)
comment4 = Comment(content='Another comment for the first post', post_id=1)

tag1 = Tag(name='animals')
tag2 = Tag(name='tech')
tag3 = Tag(name='cooking')
tag4 = Tag(name='writing')

post1.tags.append(tag1)  # Taguer le premier article avec 'animaux'
post1.tags.append(tag4)  # Taguer le premier article avec 'écriture'
post3.tags.append(tag3)  # Taguer le troisième article avec 'cuisine'
post3.tags.append(tag2)  # Taguer le troisième article avec 'technologie'
post3.tags.append(tag4)  # Taguer le troisième article avec 'écriture'


db.session.add_all([post1, post2, post3])
db.session.add_all([comment1, comment2, comment3, comment4])
db.session.add_all([tag1, tag2, tag3, tag4])

db.session.commit()

Enregistrez et fermez le fichier.

Voici, vous importez le modèle Tag. Vous supprimez tout dans la base de données en utilisant la fonction db.drop_all() pour ajouter en toute sécurité les tables des tags et post_tag et éviter tout problème courant lié à l’ajout de nouvelles tables à une base de données. Ensuite, vous créez toutes les tables à nouveau en utilisant la fonction db.create_all().

Après le code du tutoriel précédent déclarant les publications et les commentaires, vous utilisez le modèle Tag pour créer quatre tags.

Ensuite, vous ajoutez des tags aux publications en utilisant l’attribut tags qui a été ajouté via la ligne tags = db.relationship('Tag', secondary=post_tag, backref='posts') dans le fichier app.py. Vous attribuez des tags aux publications en utilisant une méthode append() similaire aux listes Python.

Ensuite, vous ajoutez les tags que vous avez créés à la session de la base de données en utilisant la fonction db.session.add_all().

Remarque:

La fonction db.create_all() ne recrée ni ne met à jour une table si elle existe déjà. Par exemple, si vous modifiez votre modèle en ajoutant une nouvelle colonne et que vous exécutez la fonction db.create_all(), la modification que vous apportez au modèle ne sera pas appliquée à la table si la table existe déjà dans la base de données. La solution est de supprimer toutes les tables de la base de données existantes avec la fonction db.drop_all() et de les recréer ensuite avec la fonction db.create_all(), comme le montre le fichier init_db.py.

Ce processus appliquera les modifications que vous apportez à vos modèles mais supprimera également toutes les données existantes dans la base de données. Pour mettre à jour la base de données et préserver les données existantes, vous devrez utiliser la migration de schéma, qui vous permet de modifier vos tables et de conserver les données. Vous pouvez utiliser l’extension Flask-Migrate pour effectuer des migrations de schéma SQLAlchemy via l’interface en ligne de commande Flask.

Exécutez le programme init_db.py pour appliquer les modifications à la base de données:

python init_db.py

Le programme devrait s’exécuter avec succès sans afficher de sortie. Si vous rencontrez une erreur, assurez-vous d’avoir apporté les modifications correctement au fichier init_db.py.

Pour consulter les publications et les tags actuellement présents dans la base de données, ouvrez l’interpréteur Python Flask:

flask shell

Exécutez le code Python suivant qui parcourt les publications et les tags:

from app import Post

posts = Post.query.all()

for post in posts:
    print(post.title)
    print(post.tags)
    print('---')

Ici, vous importez le modèle Post depuis app.py. Vous interrogez la table des publications et récupérez toutes les publications dans la base de données. Vous bouclez à travers les publications, et vous affichez le titre de la publication et la liste des tags associés à chaque publication.

Vous obtiendrez une sortie similaire à ce qui suit:

Output
Post The First
[<Tag "animals">, <Tag "writing">]
---
Post The Third
[<Tag "cooking">, <Tag "tech">, <Tag "writing">]
---
Post The Second
[]
---

Vous pouvez accéder aux noms des tags en utilisant tag.name comme démontré dans l’exemple suivant, que vous pouvez exécuter en utilisant l’interpréteur Python Flask:

from app import Post

posts = Post.query.all()

for post in posts:
    print('TITLE: ', post.title)
    print('-')
    print('TAGS:')
    for tag in post.tags:
        print('> ', tag.name)
    print('-'*30)

Ici, en plus d’afficher le titre de la publication, vous parcourez également les tags de chaque publication et affichez le nom du tag.

Vous obtiendrez une sortie similaire à ce qui suit:

OutputTITLE:  Post The First
-
TAGS:
>  animals
>  writing
------------------------------
TITLE:  Post The Third
-
TAGS:
>  cooking
>  tech
>  writing
------------------------------
TITLE:  Post The Second
-
TAGS:
------------------------------

Comme vous pouvez le voir, les balises que vous avez ajoutées aux publications dans le programme init_db.py sont correctement liées aux publications auxquelles elles ont été associées.

Pour voir une démonstration de la manière d’accéder aux publications marquées avec une balise spécifique via tag.posts, exécutez le code suivant dans le shell Flask:

from app import Tag

writing_tag = Tag.query.filter_by(name='writing').first()

for post in writing_tag.posts:
    print(post.title)
    print('-'*6)
    print(post.content)
    print('-')
    print([tag.name for tag in post.tags])
    print('-'*20)

Vous importez le modèle Tag. Ensuite, vous utilisez la méthode filter_by() sur l’attribut query en lui passant un paramètre name pour obtenir la balise writing par son nom, et vous obtenez le premier résultat en utilisant la méthode first(). Vous stockez l’objet balise dans une variable appelée writing_tag. Pour plus d’informations sur la méthode filter_by, consultez l’étape 4 du tutoriel Comment utiliser Flask-SQLAlchemy pour interagir avec les bases de données dans une application Flask.

Vous parcourez les publications marquées avec la balise writing, auxquelles vous accédez via writing_tag.posts. Vous affichez le titre de la publication, le contenu et une liste de noms de balises que vous construisez à l’aide d’une compréhension de liste basée sur les balises de la publication, auxquelles vous accédez via post.tags.

Vous obtiendrez une sortie similaire à ce qui suit:

OutputPost The Third
------
Content for the third post
-
['cooking', 'tech', 'writing']
--------------------
Post The First
------
Content for the first post
-
['animals', 'writing']
--------------------

Ici, vous voyez les deux publications qui ont été marquées avec la balise writing, et les noms des balises sont affichés dans une liste Python.

Vous pouvez maintenant accéder aux publications et à leurs balises et accéder aux publications d’une balise spécifique.

Vous avez ajouté un modèle de base de données qui représente la table des tags. Vous avez établi un lien entre les publications et les tags en utilisant une table d’association, et vous avez inséré quelques tags dans la base de données et étiqueté des publications avec eux. Vous avez accédé aux publications et à leurs tags ainsi qu’aux publications d’un tag individuel. Ensuite, vous utiliserez le shell Flask pour ajouter de nouvelles publications et de nouveaux tags et pour établir un lien entre les tags et les publications, et vous apprendrez comment supprimer des tags d’une publication.

Étape 3 — Gestion des données dans une relation de nombreux-à-plusieurs

Dans cette étape, vous utiliserez le shell Flask pour ajouter de nouvelles publications à la base de données, ajouter des tags, et établir un lien entre les publications et les tags. Vous accéderez aux publications avec leurs tags, et vous verrez comment dissocier un élément d’un autre dans les relations de nombreux-à-plusieurs.

Tout d’abord, avec votre environnement de programmation activé, ouvrez le shell Flask si ce n’est pas déjà fait:

flask shell

Ensuite, ajoutez quelques publications et tags:

from app import db, Post, Tag

life_death_post = Post(title='A post on life and death', content='life and death')
joy_post = Post(title='A post on joy', content='joy')

life_tag = Tag(name='life')
death_tag = Tag(name='death')
joy_tag = Tag(name='joy')

life_death_post.tags.append(life_tag)
life_death_post.tags.append(death_tag)
joy_post.tags.append(joy_tag)

db.session.add_all([life_death_post, joy_post, life_tag, death_tag, joy_tag])

db.session.commit()

Cela crée deux publications et trois tags. Vous étiquetez les publications avec leurs tags associés, et vous utilisez la méthode add_all() pour ajouter les éléments nouvellement créés à la session de la base de données. Ensuite, vous validez les modifications et les appliquez à la base de données en utilisant la méthode commit().

Ensuite, utilisez le shell Flask pour obtenir toutes les publications et leurs tags comme vous l’avez fait dans l’étape précédente:

posts = Post.query.all()

for post in posts:
    print(post.title)
    print(post.tags)
    print('---')

Vous obtiendrez une sortie similaire à ce qui suit:

Output
Post The First
[<Tag "animals">, <Tag "writing">]
---
Post The Third
[<Tag "cooking">, <Tag "tech">, <Tag "writing">]
---
Post The Second
[]
---
A post on life and death
[<Tag "life">, <Tag "death">]
---
A post on joy
[<Tag "joy">]
---

Vous pouvez voir que des publications ont été ajoutées avec leurs tags.

Pour démontrer comment rompre une relation entre deux éléments dans une relation de base de données de type plusieurs à plusieurs, disons que le billet Post The Third n’est plus sur la cuisine, donc vous devrez supprimer le tag cooking de celui-ci.

Tout d’abord, obtenez le billet et le tag que vous souhaitez supprimer:

from app import db, Post, Tag
post = Post.query.filter_by(title='Post The Third').first()
tag = Tag.query.filter_by(name='cooking').first()
print(post.title)
print(post.tags)
print(tag.posts)

Ici, vous récupérez le billet intitulé Post The Third en utilisant la méthode filter_by(). Vous obtenez le tag cooking. Vous imprimez le titre du billet, ses tags et les billets taggés avec le tag cooking.

La méthode filter_by() renvoie un objet de requête, et vous pouvez utiliser la méthode all() pour obtenir une liste de tous les résultats. Mais comme nous n’attendons qu’un seul résultat dans ce cas, vous utilisez la méthode first() pour obtenir le premier (et unique) résultat. Pour en savoir plus sur les méthodes first() et all(), consultez Étape 4 de Comment Utiliser Flask-SQLAlchemy pour Interagir avec les Bases de Données dans une Application Flask.

Vous obtiendrez la sortie suivante:

Output
Post The Third


[<Tag "cooking">, <Tag "tech">, <Tag "writing">]


[<Post "Post The Third">]

Ici, vous voyez le titre du billet, les tags du billet et une liste des billets taggés avec le tag cooking.

Pour supprimer le tag cooking du billet, utilisez la méthode remove() comme ceci:

post.tags.remove(tag)
db.session.commit()
print(post.tags)
print(tag.posts)

Ici, vous utilisez la méthode remove() pour dissocier le tag cooking du billet. Ensuite, vous utilisez la méthode db.session.commit() pour appliquer les modifications à la base de données.

Vous obtiendrez une sortie confirmant que la balise a été supprimée du message :

Output[<Tag "tech">, <Tag "writing">]

[]

Comme vous pouvez le voir, la balise cooking n’est plus dans la liste post.tags, et le message a été retiré de la liste tag.posts.

Quittez l’interpréteur Flask :

exit()

Vous avez ajouté de nouveaux messages et des balises. Vous avez balisé des messages et vous avez retiré des balises de messages. Ensuite, vous afficherez les balises de chaque message sur la page d’index de votre blog web Flask.

Étape 4 — Affichage des Balises Sous Chaque Message

Dans cette étape, vous éditerez le modèle d’index pour afficher les balises sous chaque message.

Tout d’abord, jetez un œil à la page d’accueil actuelle du blog web Flask.

Avec votre environnement de programmation activé, indiquez à Flask l’application (app.py dans ce cas) en utilisant la variable d’environnement FLASK_APP. Ensuite, définissez la variable d’environnement FLASK_ENV sur development pour exécuter l’application en mode développement :

export FLASK_APP=app
export FLASK_ENV=development

Ensuite, lancez l’application :

flask run

Avec le serveur de développement en cours d’exécution, visitez l’URL suivante dans votre navigateur :

http://127.0.0.1:5000/

Vous verrez une page similaire à ce qui suit :

Laissez le serveur de développement fonctionner et ouvrez une nouvelle fenêtre de terminal.

Vous devrez afficher les balises de chaque publication sur deux pages : sous chaque publication sur la page d’index et sous le contenu de la publication sur la page de la publication. Vous utiliserez le même code pour afficher les balises. Pour éviter la répétition du code, vous utiliserez une macro Jinja, qui se comporte comme une fonction Python. Une macro contient du code HTML dynamique qui peut être affiché partout où vous appelez la macro, et toute modification apportée s’applique partout où elle a été appelée, ce qui rend le code réutilisable.

Tout d’abord, ouvrez un nouveau fichier appelé macros.html dans votre répertoire templates:

nano templates/macros.html

Ajoutez le code suivant à ce fichier:

flask_app/templates/macros.html

{% macro display_tags(post) %}
    <div class="tags">
        <p>
            <h4>Tags:</h4>
            {% for tag in post.tags %}
                <a href="#" style="text-decoration: none; color: #dd5b5b">
                    {{ tag.name }}
                </a>
                |
            {% endfor %}
        </p>
    </div>
{% endmacro %}

Enregistrez et fermez le fichier.

Ici, vous utilisez le mot-clé macro pour déclarer une macro appelée display_tags() avec un paramètre appelé post. Vous utilisez une balise <div>, dans laquelle vous affichez un en-tête <h4>. Vous utilisez une boucle for pour parcourir les balises de l’objet de publication qui sera passé en argument à la macro lors de son appel, similaire à la façon dont un argument est passé dans un appel de fonction Python. Vous obtenez les balises via post.tags. Vous affichez le nom de la balise à l’intérieur d’une balise <a>. Vous éditerez plus tard la valeur de l’attribut href pour lier à une page de balises que vous créerez où toutes les publications taguées avec une balise particulière seront affichées. Vous spécifiez la fin de la macro en utilisant le mot-clé endmacro.

Ensuite, pour afficher les balises sous chaque publication sur la page d’index, ouvrez le fichier de modèle index.html:

nano templates/index.html

Tout d’abord, vous devrez importer la macro display_tags() du fichier macros.html. Ajoutez l’importation suivante en haut, au-dessus de la ligne {% extends 'base.html' %}:

flask_app/templates/index.html

{% from 'macros.html' import display_tags %}
{% extends 'base.html' %}

Ensuite, modifiez la boucle for post in posts en appelant la macro display_tags() comme suit:

flask_app/templates/index.html

{% for post in posts %}
    <div class="post">
        <p><b>#{{ post.id }}</b></p>
        <b>
            <p class="title">
                <a href="{{ url_for('post', post_id=post.id)}}">
                    {{ post.title }}
                </a>
            </p>
        </b>
        <div class="content">
            <p>{{ post.content }}</p>
        </div>

        {{ display_tags(post) }}

        <hr>
    </div>
{% endfor %}

Enregistrez et fermez le fichier.

Vous appelez la macro display_tags(), en lui passant l’objet post. Cela affichera les noms des balises sous chaque publication.

Actualisez la page d’index dans votre navigateur et vous verrez les balises sous chaque publication, comme indiqué dans l’image suivante:

Ensuite, vous ajouterez des balises sous le contenu de la publication sur la page de la publication. Ouvrez le fichier de modèle post.html:

nano templates/post.html

Tout d’abord, importez la macro display_tags en haut:

flask_app/templates/post.html

{% from 'macros.html' import display_tags %}
{% extends 'base.html' %}

Ensuite, appelez la macro display_tags(), en lui passant l’objet post sous le contenu de la publication et au-dessus de la balise <hr>:

flask_app/templates/post.html

<div class="post">
    <p><b>#{{ post.id }}</b></p>
    <b>
        <p class="title">{{ post.title }}</p>
    </b>
    <div class="content">
        <p>{{ post.content }}</p>
    </div>

    {{ display_tags(post) }}

    <hr>
    <h3>Comments</h3>

Enregistrez et fermez le fichier.

Maintenant, accédez à une page de publication:

http://127.0.0.1:5000/2

Vous verrez que les balises sont affichées de la même manière que les balises affichées sur la page d’index.

Vous avez affiché les balises que vous avez ajoutées aux publications sous chaque publication. Ensuite, vous ajouterez une nouvelle route à votre application Flask qui affiche toutes les publications étiquetées avec une étiquette spécifique. Ensuite, vous rendrez les liens d’étiquette que vous avez affichés dans cette étape fonctionnels.

Étape 5 — Affichage des balises et de leurs publications

Dans cette étape, vous ajouterez une route et un modèle à votre application web pour afficher les balises que vous avez dans votre base de données et leurs publications.

Tout d’abord, vous ajouterez une route pour afficher les publications de chaque balise. Par exemple, la route /tags/nom_de_la_balise/ affichera une page qui présente toutes les publications étiquetées avec une balise nommée nom_de_la_balise.

Ouvrez app.py pour l’éditer :

nano app.py

Ajoutez la route suivante à la fin du fichier :

flask_app/app.py


# ...

@app.route('/tags/<tag_name>/')
def tag(tag_name):
    tag = Tag.query.filter_by(name=tag_name).first_or_404()
    return render_template('tag.html', tag=tag)

Enregistrez et fermez le fichier.

Ici, vous utilisez une variable d’URL appelée nom_de_la_balise qui détermine la balise et les publications étiquetées avec elle qui seront affichées sur la page de la balise. Le nom de la balise est passé à la fonction de vue tag() via le paramètre nom_de_la_balise, que vous utilisez sur la méthode filter_by() pour interroger la balise. Vous utilisez first_or_404() pour obtenir l’objet balise et le stocker dans une variable appelée balise, ou pour répondre avec un message d’erreur 404 Not Found dans le cas où aucune balise avec le nom donné n’existe dans la base de données.

Ensuite, vous affichez un fichier modèle appelé tag.html, en lui passant l’objet balise.

Ouvrez le nouveau templates/tag.html pour l’éditer :

nano templates/tag.html

Ajoutez le code suivant à celui-ci :

flask_app/templates/tag.html

{% from 'macros.html' import display_tags %}
{% extends 'base.html' %}

{% block content %}
    <span class="title">
        <h1>{% block title %} Posts Tagged with "{{ tag.name }}" {% endblock %}</h1>
    </span>
    <div class="content">
        {% for post in tag.posts %}
        <div class="post">
            <p><b>#{{ post.id }}</b></p>
            <b>
                <p class="title">
                    <a href="{{ url_for('post', post_id=post.id)}}">
                        {{ post.title }}
                    </a>
                </p>
            </b>
            <div class="content">
                <p>{{ post.content }}</p>
            </div>

            {{ display_tags(post) }}

            <hr>
        </div>
        {% endfor %}
    </div>
{% endblock %}

Enregistrez et fermez le fichier.

Vous importez la macro display_tags() depuis macros.html, et étendez le modèle de base.

Dans le bloc de contenu, vous définissez un titre avec le nom de la balise inclus. Ensuite, vous bouclez à travers les articles étiquetés avec la balise donnée, auxquels vous accédez via tag.posts. Vous affichez l’ID de l’article, le titre de l’article et le contenu de l’article. Ensuite, vous appelez la macro display_tags() pour afficher toutes les balises des articles.

Avec votre serveur de développement en cours d’exécution, accédez à l’URL suivante :

http://127.0.0.1:5000/tags/writing/

C’est la page pour la balise writing. Comme vous pouvez le voir, tous les articles étiquetés avec writing sont affichés :

Maintenant, modifiez la macro display_tags() pour rendre les liens de balises fonctionnels. Ouvrez macros.html :

nano templates/macros.html

Modifiez la valeur de l’attribut href comme suit :

flask_app/templates/macros.html


{% macro display_tags(post) %}
    <div class="tags">
        <p>
            <h4>Tags:</h4>
            {% for tag in post.tags %}
            <a href="{{ url_for('tag', tag_name=tag.name) }}"
               style="text-decoration: none; color: #dd5b5b">
                    {{ tag.name }}
                </a>
                |
            {% endfor %}
        </p>
    </div>
{% endmacro %}

Enregistrez et fermez le fichier.

Actualisez les pages où la macro display_tags() a été utilisée, et vous verrez que les liens de balises sont maintenant fonctionnels :

http://127.0.0.1:5000/
http://127.0.0.1:5000/2/
http://127.0.0.1:5000/tags/writing/

Comme vous pouvez le voir, l’utilisation de macros Jinja vous permet de réutiliser du code, et éditer une macro applique des changements à travers plusieurs modèles.

Vous avez ajouté une page pour les balises individuelles où les utilisateurs peuvent voir tous les articles étiquetés avec une balise spécifique, et les balises sous les articles mènent désormais à cette nouvelle page.

Conclusion

Les balises que vous avez ajoutées à votre système de blogging démontrent comment gérer les relations many-to-many en utilisant l’extension Flask-SQLAlchemy. Vous avez appris comment lier deux tables liées à l’aide d’une table d’association (également appelée une table de jointure), associer une entrée à une autre, ajouter l’entrée à la base de données, et accéder et dissocier des données à partir d’une entrée.

Si vous souhaitez en savoir plus sur Flask, consultez les autres tutoriels de la série Comment Construire des Applications Web avec Flask.

Source:
https://www.digitalocean.com/community/tutorials/how-to-use-many-to-many-database-relationships-with-flask-sqlalchemy