Flask, données et IA

def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)
    db.init_app(app)
    from app.routes import main_bp
    app.register_blueprint(main_bp)
    return app

main_bp = Blueprint("main", __name__)

@main_bp.route("/artists")
def artists():
    rows = Artist.query.order_by(Artist.Name).all()
    return render_template("artists.html", items=rows)

• Application factory : créer l’app dans une fonction, pour pouvoir en créer plusieurs (tests, configurations différentes) et éviter les imports circulaires.
• Blueprint : un groupe de routes enregistré sur l’app ; url_for("main.artists").
• Paramètres d’URL : @app.route("/model/<model_name>") ; convertisseurs <int:id>, <path:p>.
• Méthodes : methods=["POST"]. Corps JSON : request.get_json() ; formulaire : request.form ; fichier : request.files["image"].
• Query string : request.args.get("k", défaut) donne une valeur, request.args.getlist("k") donne toutes les valeurs d’un paramètre répété.
• Réponse JSON : return jsonify(obj), 400 (le tuple fixe le code HTTP). Erreur : abort(404).
• app.run(host="0.0.0.0") pour écouter hors du conteneur ; le serveur intégré n’est fait que pour le développement (en production : Gunicorn).

• {{ variable }} affiche (échappé automatiquement contre le XSS) ; {% if %}…{% elif %}…{% endif %} ; {% for x in liste %}…{% else %}(liste vide){% endfor %}.
• Héritage : {% extends "base.html" %} et {% block content %}{% endblock %} pour ne pas répéter l’en-tête.
• Liens et fichiers statiques : {{ url_for('static', filename='style.css') }}.
• |safe désactive l’échappement : uniquement pour du HTML de confiance.

class Artist(db.Model):
    __tablename__ = "artists"
    ArtistId: Mapped[int] = mapped_column(primary_key=True)
    Name: Mapped[str]
    albums: Mapped[list["Album"]] = relationship(back_populates="artist")

class Album(db.Model):
    __tablename__ = "albums"
    AlbumId: Mapped[int] = mapped_column(primary_key=True)
    ArtistId: Mapped[int] = mapped_column(ForeignKey("artists.ArtistId"))
    artist: Mapped[Artist] = relationship(back_populates="albums")

• Configuration : SQLALCHEMY_DATABASE_URI = "sqlite:///chemin/chinook.db" ; SQLALCHEMY_ECHO = True pour voir le SQL.
• back_populates relie les deux côtés de la relation ; la clé étrangère est du côté « n ».
• Requêtes : Model.query.filter_by(Name="AC/DC").first() (style 1.x) ou db.session.execute(select(Artist).where(...)).scalars() (style 2.0).
• Écrire : db.session.add(obj) puis db.session.commit() ; en cas d’erreur rollback().

• Série temporelle : des mesures horodatées. InfluxDB est optimisé pour en écrire et en agréger beaucoup.
• Bucket : la base (avec une durée de rétention). Measurement : l’équivalent d’une table (weather_current).
• Tag : métadonnée indexée, texte, pour filtrer et grouper (location, symbol). Field : la valeur mesurée, non indexée (temperature_2m, price).
• Point = measurement + tags + fields + horodatage. Une série = une combinaison measurement + tags + field.

from(bucket: "weather")
  |> range(start: -7d)                                     // fenêtre de temps (obligatoire)
  |> filter(fn: (r) => r._measurement == "weather_current")
  |> filter(fn: (r) => r.location == "annecy")             // filtre sur un tag
  |> filter(fn: (r) => r._field == "temperature_2m")
  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false)  // une moyenne par heure

• Colonnes du résultat : _time, _value, _field, _measurement et les tags.
• Découvrir le schéma : schema.measurements(), schema.fieldKeys(), schema.tagValues() (import "influxdata/influxdb/schema").
• Client Python : InfluxDBClient(url, token, org).query_api().query(flux) renvoie des tables de records ; penser à client.close().

• Charger le modèle une seule fois (au démarrage ou dans un cache), jamais à chaque requête.
• Le prétraitement doit reproduire celui de l’entraînement : taille (28×28, 32×32), canaux, normalisation (/255), couleurs (MNIST : trait blanc sur fond noir, d’où l’invert), cadrage.
• Forme d’entrée Keras : (batch, hauteur, largeur, canaux), d’où reshape(1, 28, 28, 1).
• np.argmax(preds) donne la classe ; la confiance n’est une probabilité que si la dernière couche est un softmax.
• Image reçue en base64 (data URL) : retirer le préfixe data:image/png;base64,, puis base64.b64decode et Image.open(io.BytesIO(...)).
• Formats : .h5 (ancien, dépend de la version de Keras) et .keras (Keras 3). Fixer les versions dans requirements.txt.
• Rappel CNN : convolution (filtres appris) → activation (ReLU) → pooling (réduit la taille) → … → aplatissement → couches denses → softmax.

FROM python:3.12-slim
WORKDIR /TP4
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt   # gardé en cache tant que requirements.txt ne change pas
COPY . .
EXPOSE 5005
CMD ["python", "exo.py"]

• ports: "5005:5005" = port de l’hôte : port du conteneur. Deux services ne peuvent pas publier le même port de l’hôte.
• volumes: - .:/TP4 monte le code : pratique en développement (rechargement), à éviter en production.
• Variables d’environnement : environment: ou env_file: .env, lues avec os.getenv().

• Injection : ne jamais coller une entrée utilisateur dans du SQL ou du Flux. SQLAlchemy paramètre ses requêtes (?) ; pour Flux, valider la valeur contre une liste autorisée.
• Secrets (jetons, mots de passe, SECRET_KEY) : variables d’environnement, fichier .env dans .gitignore, jamais dans le dépôt.
• Mode debug : désactivé en production (débogueur interactif = exécution de code à distance).
• Envoi de fichiers : limiter la taille (MAX_CONTENT_LENGTH), vérifier le type, secure_filename() pour le nom.
• XSS : Jinja échappe par défaut ; ne pas utiliser |safe sur des données utilisateur.