Programmation Web avec Flask (Partie3)

Publié le 1 octobre 2019 par Latyr Ndiaye

Dans cette partie qui constitue une suite de celle précédente, nous allons revenir sur les extensions de Flask.

I.14. Les Extensions du flask

Flask est souvent qualifié de micro-framework, car une fonctionnalité principale inclut WSGI et un routage basé sur Werkzeug et un moteur de modèle basé sur Jinja2 . En outre, la structure Flask prend en charge les cookies et les sessions, ainsi que les assistants Web tels que JSON , les fichiers statiques, etc. Évidemment, cela ne suffit pas pour le développement d'une application Web à part entière. C'est là que les extensions Flask entrent en jeu. Les extensions de flask donnent une extensibilité au framework Flask.

Il existe un grand nombre d'extensions Flask disponibles. Une extension Flask est un module Python, qui ajoute un type de fonctionnalité spécifique à l'application Flask. Flask Extension Registry est un répertoire d'extensions disponibles. Les extensions peuvent être téléchargées par l' utilitaire pip .

On peut citer quelques extensions intéressantes de flask :

Flask Mail - fournit une interface SMTP à l'application Flask
Flask WTF - ajoute le rendu et la validation de WTForms
Flask SQLAlchemy - ajoute le support SQLAlchemy à l'application Flask
Flask Sijax - Interface pour Sijax - Bibliothèque Python / jQuery qui rend AJAX facile à utiliser dans les applications Web

Chaque type d'extension fournit généralement une documentation détaillée sur son utilisation. Puisqu'une extension est un module Python, vous devez l'importer pour pouvoir l'utiliser. Les extensions de flask sont généralement appelées flask-nomExtention.

Pour importer une extention on utilise :

from flask_ nomExtention import [class, function]

Pour les versions de Flask ultérieures à 0.7, vous pouvez également utiliser la syntaxe -

from flask.ext import NomExtension

Pour cette utilisation, un module de compatibilité doit être activé. Il peut être installé en lançant flaskext_compat.py

import flaskext_compat
flaskext_compat.activate()
from flask.ext import NomExtension

15. Utilisation de la base de données SQLite

Python a un support intégré pour SQlite . Le module SQlite3 est livré avec la distribution Python. Dans cette section, nous verrons comment une application Flask interagit avec SQLite.

Prérequis :

Installer le paquet sqlite3 pour la gestion des bases de données SQLite comme suit :

On écrit le programme python sqlitecreate.py pour créer une base de données SQLite 'database.db' et créez-y une table d'étudiants.

import sqlite3

conn = sqlite3.connect('database.db')

print "Opened database successfully";

conn.execute('CREATE TABLE etudiants (nom TEXT,prenom TEXT, addr TEXT, ville TEXT, mpass TEXT)')

print "Table created successfully";

conn.close()

On l’exécute comme suit pour créer la base et la table nécessaires :

Installer le logiciel sqlitebrowser pour visualiser la base comme suit :

On lance sqlitebrowser en précisant le nom de la base à visualiser :

Les étapes seront les suivantes :

a. Création du fichier templates/accueil.html comme suit :

<!doctype html>

<html>

<body>

<h2><a href = "/entrernouveau">Ajouter un nouvel etudiant</a></h2>

<h2><a href = "/list">Lister les etudiant</a></h2>

</body>

</html>

b. Création du formulaire d’ajout d’étudiant templates/etudiantsqlite.html comme suit :

<html>

<body>

<form action = "{{ url_for('addrec') }}" method = "POST">

<h3>Information Etudiant</h3>

Nom<br>

<input type = "text" name = "nom" /></br>

Prenom<br>

<input type = "text" name = "prenom" /></br>

Adresse<br>

<textarea name = "add" ></textarea><br>

Ville<br>

<input type = "text" name = "ville" /><br>

Mot de passe<br>

<input type = "text" name = "mpass" /><br>

<input type = "submit" value = "valider" /><br>

</form>

</body>

</html>

c. Création du fichier templates/list.html pour l’affichage des étudiants comme suit :

<!doctype html>

<html>

<body>

<table border = 1>

<thead>

<td>Nom</td>

<td>Prenom</td>

<td>Adresse</td>

<td>Ville</td>

<td>Mot de Passe</td>

</thead>

{% for row in rows %}

<tr>

<td>{{row["nom"]}}</td>

<td>{{row["prenom"]}}</td>

<td>{{row["addr"]}}</td>

<td> {{ row["ville"]}}</td>

<td>{{row['mpass']}}</td>

</tr>

{% endfor %}

</table>

<a href = "/">Aller page accueil</a>

</body>

</html>

d. Création du programme python sqlite.py comme suit :

from flask import Flask, render_template, request

import sqlite3 as sql

app = Flask(__name__)

@app.route('/')

def home():

return render_template('accueil.html')

@app.route('/entrernouveau')

def new_student():

return render_template('etudiantsqlite.html')

@app.route('/addrec',methods = ['POST', 'GET'])

def addrec():

if request.method == 'POST':

try:

nom = request.form['nom']

prenom = request.form['prenom']

addr = request.form['add']

ville = request.form['ville']

mpass = request.form['mpass']

with sql.connect("database.db") as con:

cur = con.cursor()

cur.execute("INSERT INTO etudiants (nom,prenom,addr,ville,mpass)VALUES (?,?,?,?,?)",(nom,prenom,addr,ville,mpass) )

con.commit()

msg = "Enregistrement reussi"

except:

con.rollback()

msg = "erreur insertion "

finally:

return render_template("resultsqlite.html",msg = msg)

con.close()

@app.route('/list')

def list():

con = sql.connect("database.db")

con.row_factory = sql.Row

cur = con.cursor()

cur.execute("select * from etudiants")

rows = cur.fetchall();

return render_template("list.html",rows = rows)

if __name__ == '__main__':

app.run(debug = True)

e. Création du fichier templates/resultsqlite.html qui affiche le résultat comme suit :

<!doctype html>

<html>

<body>

resultat d ajout : {{ msg }}

<h2><a href = "\">Aller page accueil</a></h2>

</body>

</html>

f. On exécute le programme sqlite.py comme suite

On lance un navigateur comme suit

On clique sur ajouter un nouvel étudiant et on renseigne les champs comme suit :

Après validation on obtient la confirmation d’ajout et on clique sur Aller page d’accueil pour retourner à la page d’accueil comme suit :

En cliquant Lister les étudiants on a leur liste comme suit :

NB : Nous avons intégré tout d’abord l’étudiant latyr ndiaye sans capture avant d’intégrer l’étudiant Amadou Bory Diallo.

II.1 . Objectifs pédagogiques : Envoi de fichier

La gestion du téléchargement de fichiers dans Flask est très simple. Il a besoin d'un formulaire HTML avec son attribut enctype défini sur 'multipart / form-data', en publiant le fichier dans une URL. Le gestionnaire d'URL extrait le fichier de l'objet request.files [ ] et l'enregistre à l'emplacement souhaité.

Chaque fichier téléchargé est d'abord enregistré dans un emplacement temporaire sur le serveur, avant d'être enregistré dans son emplacement ultime. Le nom du fichier de destination peut être codé en dur ou peut être obtenu à partir de la propriété filename de l'objet request.files [fichier] . Toutefois, il est recommandé d’en obtenir une version sécurisée à l’aide de la fonction secure_filename () .

Il est possible de définir le chemin du dossier de téléchargement par défaut et la taille maximale du fichier téléchargé dans les paramètres de configuration de l'objet Flask.

app.config ['UPLOAD_FOLDER']	Définit le chemin du dossier de téléchargement
app.config ['MAX_CONTENT_PATH']	Spécifie la taille maximale du fichier à télécharger - en octets

Le code suivant contient la règle d'URL '/upload' qui affiche 'upload.html' à partir du dossier des modèles et la règle d'URL '/upload-file' qui appelle le processus de téléchargement chargé de la fonction uploader () .

'upload.html' a un bouton de sélection de fichier et un bouton d' envoi .

a. On crée le fichier templates/upload.html comme suit :

<html>

<body>

<form action = "http://localhost:5000/uploader" method = "POST" enctype = "multipart/form-data">

<input type = "file" name = "file" />

<input type = "submit"/>

</form>

</body>

</html>

b. On crée le programme python upload.py comme suit :

#!/usr/bin/env python

# -*- coding: utf8 -*-

from flask import Flask, render_template, request

from werkzeug import secure_filename

app = Flask(__name__)

@app.route('/upload')

def upload_file():

return render_template('upload.html')

@app.route('/uploader', methods = ['GET', 'POST'])

def upload():

if request.method == 'POST':

f = request.files['file']

f.save(secure_filename(f.filename))

return 'Téléchargement du fichier reussi'

if __name__ == '__main__':

app.run(debug = True)

c. On lance le programme upload.py et on teste à travers un navigateur comme suit :

On clique sur Choisir un fichier pour aller sélectionner le fichier comme suit :

Après validation on obtient la capture suivante :

II.2. Objectifs pédagogiques : Les Cookies

Un cookie est stocké sur l'ordinateur d'un client sous la forme d'un fichier texte. Son objectif est de mémoriser et de suivre les données relatives à l'utilisation d'un client pour une meilleure expérience des visiteurs et des statistiques de site.

Un objet Request contient un attribut de cookie. C'est un dictionnaire qui contient toutes les variables de cookie et les valeurs correspondantes qu'un client à transmettre. En plus, un cookie stocke également son heure d'expiration, le chemin d'accès et le nom de domaine du site.

Dans Flask, les cookies sont définis sur l'objet de réponse. Utilisez la fonction make_response () pour obtenir un objet de réponse à partir de la valeur de retour d’une fonction de vue. Après cela, utilisez la fonction set_cookie () de l'objet response pour stocker un cookie.

La lecture d’un cookie est facile. La méthode get() de l' attribut request.cookies est utilisée pour lire un cookie.

Dans l'application Flask suivante, un simple formulaire s'ouvre lorsque vous visitez l'URL '/' .

a. On crée le fichier templates/cookies.html comme suit :

<html>

<body>

<form action = "/setcookie" method = "POST">

<p><h3>Entrer vos paramètres de connexion</h3></p>

<p>Login :<input type = 'text' name = 'login'/></p>

<p>Password<input type = 'text' name = 'pass'/></p>

<p><input type = 'submit' value = 'Connexion'/></p>

</form>

</body>

</html>

Le formulaire est envoyé à l'URL '/cookie'. La fonction de vue associée qui définit le login et le password de l'utilisateur

b. On crée le programme python cookies.py comme suit :

from flask import Flask, request, make_response, render_template

app = Flask(__name__)

@app.route('/')

def index():

return render_template('cookies.html')

@app.route('/cookie', methods = ['POST', 'GET'])

def cookie():

if request.method == 'POST':

login = request.form['login']

password = request.form['pass']

resp = make_response(render_template('readcookies.html'))

resp.set_cookie('login', login )

resp.set_cookie('pass', password )

return resp

@app.route('/affichecookie')

def affichecookie():

login = request.cookies.get('login')

password = request.cookies.get('pass')

return '<h3>Bonjour votre vos parametres de connexion sont :'+login+' '+password+'</h3>'

if __name__ == '__main__':

app.run(debug = True)

c. On crée le fichier templates/readcookies.html pour afficher les cookies comme suit :

<!doctype html>

<html>

<body>

<h2><a href = "/affichecookie">Afficher les cookies</a></h2>

</body>

</html>

On lance le programme cookies.py et on teste à travers un navigateur comme suit :

On renseigne le login et le mot de passe comme suit :

Après validation on obtient la page suivante :

On clique sur afficher les cookies comme suit :

II.3. Objectifs pédagogiques :Session

Contrairement à un cookie, les données de session sont stockées sur le serveur. La session est l'intervalle de temps lorsqu'un client se connecte à un serveur et s'en déconnecte. Les données qui doivent être conservées au cours de cette session, sont stockées dans un répertoire temporaire sur le serveur.

Une session avec chaque client se voit attribuer un identifiant de session . Les données de la session sont stockées au-dessus des cookies et le serveur les signe de manière cryptographique. Pour ce cryptage, une application Flask nécessite un SECRET_KEY défini .

L'objet de session est également un objet de dictionnaire contenant des paires clé-valeur de variables de session et des valeurs associées.

Par exemple, pour définir une variable de session 'nom d'utilisateur' , utilisez l'instruction

Session[‘username’] = ’admin’

Pour libérer une variable de session, utilisez la méthode pop () .

session.pop('username', None)

Le code suivant est une démonstration simple des travaux de session dans Flask. L'URL '/' invite simplement l'utilisateur à se connecter, car la variable de session 'username' n'est pas définie.

a) On crée le fichier templates/session.html comme suit :

<form action = "/login" method = "post">

<p>login :<input type = "text" name ="login" /></p>

<p><input type = "submit" value = "Valider"/></p>

</form>

b) On crée le programme python session.py comme suit :

#!/usr/bin/env python

# -*- coding: utf8 -*-

from flask import Flask, session, redirect, url_for, escape, request, render_template

app = Flask(__name__)

app.secret_key = 'AlTd1@#0'

@app.route('/')

def index():

if 'login' in session:

username = session['login']

return 'Votre login est : ' + username + '<br>' + \

"<b><a href = '/logout'>Se deconnecter</a></b>"

return "Vous n etes pas connectes <br><a href = '/login'></b>" + \"Se connecter</b></a>"

@app.route('/login', methods = ['GET', 'POST'])

def login():

if request.method == 'POST':

session['login'] = request.form['login']

return redirect(url_for('index'))

return render_template('session.html')

@app.route('/logout')

def logout():

# remove the username from the session if it is there

session.pop('login', None)

return redirect(url_for('index'))

if __name__ == '__main__':

app.run(debug = True)

c) On lance le programme session.py comme suit

d) On ouvre un navigateur comme suit :

e) On clique sur Se connecter et on renseigne le login comme suit :

f) Après validation on obtient la confirmation de la connexion comme le montre la figure suivante

Prochaine partie sur WTF et Mail de Flask...

Abonnez-vous

Partagez