Qu'est-ce que Flask ?

Flask est un **micro-framework** web Python. "Micro" ne signifie pas "limité", mais "minimaliste".

Par défaut, Flask ne fait que deux choses :

1. Routage : Mapper des URLs à des fonctions Python (@app.route).
2. Templating : Rendre du HTML via le moteur de template Jinja2.

Tout le reste (BDD, formulaires, authentification, admin) est ajouté par des **extensions** (ex: Flask-SQLAlchemy, Flask-WTF, Flask-Login).

Philosophie

"Non-opinionated" (Non-directif) : Flask ne vous impose aucune structure de projet ni aucun composant. Vous êtes libre de choisir vos outils.

WSGI : C'est une application WSGI (Web Server Gateway Interface), le standard Python pour communiquer avec les serveurs web (Gunicorn, uWSGI).

app.py (Fichier minimal)

C'est le "Hello World" classique de Flask.

from flask import Flask

# 1. Créer l'instance de l'application
app = Flask(__name__)

# 2. Définir une "route" (un "décorateur")
#    (Lier l'URL "/" à la fonction 'home')
@app.route("/")
def home():
    # 3. Retourner la réponse
    return "Hello, IDEO-Lab!"

@app.route("/about")
def about():
    return "Page à propos."

# (Optionnel: Permet 'python app.py')
if __name__ == "__main__":
    app.run(debug=True)

Lancement

# (Si .flaskenv est configuré)
$ flask run
 * Running on http://127.0.0.1:5000

# (Si on lance le fichier directement)
$ python app.py

@app.route()

Le décorateur @app.route lie une URL à une fonction (une "vue").

Méthodes HTTP (methods)

Par défaut, une route n'accepte que GET. Pour POST (formulaires), il faut l'autoriser.

from flask import request

# Accepte GET (défaut)
@app.route('/articles')
def article_list():
    return "Liste des articles"

# Accepte GET et POST
@app.route('/contact', methods=['GET', 'POST'])
def contact():
    if request.method == 'POST':
        # (request.form['email']...)
        return "Formulaire reçu !"
    else:
        # (render_template('contact.html')...)
        return "Affiche le formulaire"
        
# Raccourcis (préférés)
@app.get('/profile')
def profile_get(): ...
    
@app.post('/profile')
def profile_post(): ...

Objets request & response

Flask (comme Django) fournit des objets pour gérer la requête et la réponse.

from flask import request, make_response, redirect, url_for

@app.route('/data')
def get_data():
    # --- Request (Requête) ---
    methode = request.method # 'GET'
    user_agent = request.headers.get('User-Agent')
    
    # --- Response (Réponse) ---
    
    # 1. Simple (string)
    # return "OK"
    
    # 2. make_response (pour headers/status)
    response = make_response("Contenu custom", 201)
    response.headers['X-Mon-Header'] = 'valeur'
    return response
    
    # 3. Redirect
    # return redirect('/login')
    # (Mieux: utiliser 'url_for' (comme 'name' Django))
    # return redirect(url_for('login_page'))

1. Path Parameters (<variable>)

Variables dans l'URL. Passées en argument à la fonction.

# (Route: /articles/123)
@app.route('/articles/<int:article_id>')
def show_article(article_id):
    # 'article_id' est 123 (auto-converti en 'int')
    return f"Affichage de l'article {article_id}"

# (Route: /users/alice)
@app.route('/users/<string:username>')
def show_user(username):
    # 'username' est "alice" (string)

2. Query Parameters (request.args)

Variables après le ? (/search?q=test&page=2). Gérées via l'objet global request.

from flask import request

@app.route('/search')
def search():
    # request.args est un dictionnaire
    
    # ('q' est requis, 'page' est optionnel)
    terme = request.args.get('q')
    page = request.args.get('page', default=1, type=int)
    
    return f"Résultats pour '{terme}' (Page {page})"

Jinja2 (Le Moteur de Template)

Jinja2 (par le créateur de Flask) est le moteur de template. C'est (presque) la même syntaxe que Django.

Flask cherche les templates dans un dossier nommé templates/ à la racine du projet.

app.py (Passer le contexte)

from flask import render_template

@app.route('/profile')
def profile():
    # Données à passer au template
    user_data = {
        'nom': 'Alice',
        'email': 'alice@mail.com',
        'tags': ['python', 'flask', 'django']
    }
    
    # 1. Nom du fichier (dans templates/)
    # 2. Variables (contexte)
    return render_template(
        'profile.html',
        user=user_data,
        is_admin=True
    )

templates/profile.html

Profil de {{ user.nom }}

{% if is_admin %}
  
Accès Admin
{% endif %}


  {% for tag in user.tags %}
    
{{ tag|capitalize }}
  {% else %}
    
Aucun tag.
  {% endfor %}


{{ "
Titre
" | safe }}

templates/layout.html (Le Parent)

(Identique à Django base.html)

    


    
    
    

        {% block content %}
        {% endblock %}
    
    
    

templates/home.html (L'Enfant)

Utilise {% extends %} et remplit les blocs.

{% extends "layout.html" %}

{% block title %}Page d'Accueil{% endblock %}

{% block content %}
  
Bienvenue !
  
Ceci est la page d'accueil.
{% endblock %}

{% block footer %}
  {{ super() }} - Tous droits réservés.
{% endblock %}

L'ORM de référence en Python

SQLAlchemy est le principal "Toolkit SQL" et "Object Relational Mapper (ORM)" de Python. Il est indépendant de Flask.

Il offre deux modes d'utilisation :

1. Core (Query Builder)

Une abstraction "Pythonique" de SQL. Vous manipulez des objets select(), table(). Plus proche de SQL, moins "magique".

sel = select(users_table).where(users_table.c.name == 'alice')

2. ORM (Modèle Objet)

(Le plus utilisé avec Flask). Vous définissez des classes (Modèles) qui mappent vos tables. Vous ne manipulez que des objets.

# (SQLAlchemy ORM)
users = session.query(User).filter_by(name='alice').all()

# (Flask-SQLAlchemy - encore plus simple)
users = User.query.filter_by(name='alice').all()

Flask-SQLAlchemy

Flask-SQLAlchemy est une extension qui intègre SQLAlchemy (ORM) à Flask (gestion de la session, config).

1. Installation

# (Activez votre venv)
pip install Flask-SQLAlchemy

# (Installez le "driver" de BDD, ex: Postgres)
pip install psycopg2-binary
# (ou 'pip install mysqlclient' pour MariaDB)

2. Configuration (.env)

Définissez l'URL de connexion (similaire à Django).

# .env
# (PostgreSQL)
DATABASE_URI="postgresql://user:pass@host:port/db_name"

# (MariaDB)
# DATABASE_URI="mysql+mysqlclient://user:pass@host:port/db_name"

# (SQLite)
# DATABASE_URI="sqlite:///project.db"

3. Initialisation (app.py)

Liez l'app Flask à l'objet db.

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import os

# 1. Créer l'app
app = Flask(__name__)

# 2. Charger la config depuis .env
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URI")
# (Optionnel: désactiver le tracking, gourmand)
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

# 3. Initialiser l'objet 'db'
db = SQLAlchemy(app)

# (Vos modèles viendront ici...)
# class User(db.Model): ...

# (Vos routes)
@app.route("/")
def home():
    return "OK"

db.ForeignKey (Le "Lien" SQL)

Définit la contrainte physique (colonne) dans la BDD.
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

db.relationship (La "Magie" ORM)

Définit la relation *objet*. Ne crée *pas* de colonne. Permet d'accéder aux objets liés (ex: user.posts).

backref (Référence arrière)

posts = db.relationship('Post', backref='auteur') (dans User) est un raccourci.
Il crée la relation user.posts (Liste de Posts).
Il crée *aussi* la relation post.auteur (l'objet User).

Table "Many-to-Many" (Pivot)

(Ex: Post <-> Tag)

# 1. Table d'association
tags_pivot = db.Table('tags_pivot',
    db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
    db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
)

class Post(db.Model):
    # ...
    tags = db.relationship('Tag', secondary=tags_pivot,
                           backref='posts', lazy='dynamic')
                           
class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), unique=True)

Flask-Migrate

Ne *jamais* utiliser db.create_all() en production.
Flask-Migrate (basé sur Alembic) est l'outil (similaire à manage.py migrate) pour gérer les changements de schéma BDD (migrations).

Installation

pip install Flask-Migrate

Configuration (app.py)

...
from flask_migrate import Migrate

app = Flask(__name__)
db = SQLAlchemy(app)
# (Lier l'app et la BDD à Migrate)
migrate = Migrate(app, db)

# (Modèles...)
class User(db.Model): ...

# (Routes...)

Flux de travail (flask db ...)

Nécessite FLASK_APP=app.py (ou .flaskenv).

# 1. (Une fois) Créer le dossier 'migrations/'
$ flask db init

# 2. (Chaque fois que 'models.py' change)
#    Générer la migration (compare Modèles vs BDD)
$ flask db migrate -m "Ajout table Post"
# (Crée 'migrations/versions/abc_ajout_table_post.py')

# 3. Appliquer la migration à la BDD
$ flask db upgrade

# (Annuler)
$ flask db downgrade

Update (Mise à jour)

@app.route('/promote/<int:id>')
def promote_user(id):
    # 1. Lire (depuis BDD)
    user = db.session.get(User, id)
    if not user:
        abort(404)
        
    # 2. Modifier (en mémoire)
    user.is_admin = True
    
    # 3. Valider (exécute l'UPDATE)
    db.session.commit()
    
    return f"{user.username} est admin."

Delete (Suppression)

@app.route('/delete/<int:id>')
def delete_user(id):
    # 1. Lire (depuis BDD)
    user = db.session.get(User, id)
    if not user:
        abort(404)
        
    # 2. Supprimer (de la session)
    db.session.delete(user)
    
    # 3. Valider (exécute le DELETE)
    db.session.commit()
    
    return f"{user.username} supprimé."

Problème (Gros app.py)

Mettre toutes les routes dans app.py devient ingérable.
Les Blueprints (Schémas) sont l'équivalent des "Apps" Django. Ils permettent de grouper les routes, templates et statiques par fonctionnalité (ex: auth, articles).

Structure (Factory Pattern)

mon_projet/
├── app/
│   ├── __init__.py      (Contient create_app())
│   ├── models.py        (Modèles DB)
│   ├── routes_auth.py   (Blueprint 'auth')
│   ├── routes_article.py(Blueprint 'articles')
│   └── templates/
└── run.py               (Lanceur)

Définition (routes_auth.py)

from flask import Blueprint, render_template

# 1. Créer le Blueprint
auth_bp = Blueprint('auth_bp', __name__)

@auth_bp.route('/login')
def login():
    return render_template('auth/login.html')

Enregistrement (app/__init__.py)

from flask import Flask
from .models import db

def create_app():
    app = Flask(__name__)
    app.config.from_envvar(...)
    db.init_app(app)
    
    # 2. Enregistrer les Blueprints
    from . import routes_auth
    app.register_blueprint(routes_auth.auth_bp, url_prefix='/auth')
    
    return app

Serveur WSGI (Gunicorn)

Le flask run est un serveur de **développement**. En production, on utilise un serveur WSGI (comme **Gunicorn**) pour gérer les workers (processus).

pip install gunicorn

Lancement (Manuel)

([module]:[variable])

# (Si app.py contient 'app = Flask(...)')
gunicorn -w 4 app:app

# (Si on utilise le pattern 'Factory' (create_app))
gunicorn -w 4 'app:create_app()'

Service systemd

(Voir guide Nginx 3.1 pour le gunicorn.service complet)

[Service]
User=ideo_user
WorkingDirectory=/home/ideo_user/mon_projet_flask
ExecStart=/home/ideo_user/mon_projet_flask/.venv/bin/gunicorn \
    --workers 4 \
    --bind unix:/run/gunicorn_flask.sock \
    'app:create_app()'
...

Flask CLI & App

# (Configurer .flaskenv)
FLASK_APP=app.py
FLASK_DEBUG=1

# Lancer le serveur
flask run

# Lancer la CLI (REPL)
flask shell

# Lancer les commandes 'db' (Migrate)
flask db init
flask db migrate -m "..."
flask db upgrade

SQLAlchemy (db.session)

# Create
user = User(username='new')
db.session.add(user)
db.session.commit()

# Read
user = db.session.get(User, 1)
user = User.query.get_or_404(1)
users = User.query.filter_by(is_admin=True).all()
user = User.query.filter(User.age > 18).first()

# Update
user = db.session.get(User, 1)
user.username = 'new_name'
db.session.commit()

# Delete
user = db.session.get(User, 1)
db.session.delete(user)
db.session.commit()