Chapitre 7 - Flask et introduction au SQL en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapitre 7 - Flask et introduction au SQL en Python\n",
    "==="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce chapitre a pour but de vous faire découvrir l'utilisation de SQL en Python et avec Flask en particulier.\n",
    "\n",
    "Notre projet d'application Gazetteer se précise donc. Pour ne pas avoir à passer trop de temps sur d'autres tâches, voici un modèle de base de données pour le projet (très minimal) :\n",
    "\n",
    "![Modele](images/datamodel.png)\n",
    "\n",
    "Notre modèle est donc fait de 3 types de données et d'un lien pour deux d'entre eux. Notez qu'il est nécessaire d'avoir un `place` pour avoir un `variante`.\n",
    "\n",
    "Vous pouvez trouver dans le dossier `cours-flask` l'ensemble des données nécessaires pour créer la base de données. Cependant, nous proposons de vous aider dans cette tâche. Pour créer la base de données, vous aurez besoin : \n",
    "\n",
    "- de MySQL installé sur votre ordinateur\n",
    "- d'un accès administrateur à cette base de données\n",
    "- d'un terminal ou d'une interface pour se connecter à cette base\n",
    "\n",
    "Si vous avez MySQL DB Browser, vous pouvez importer le fichier `cours-flask/data.sql`\n",
    "\n",
    "Sinon, vous pouvez taper :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat cours-flask/data.sql | sqlite3 cours-flask/db.sqlite"
   ]
  },
  {
   "attachments": {
    "sql.transaction.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Travailler avec une base SQL \n",
    "\n",
    "### Anatomie d'une transaction SQL\n",
    "\n",
    "Les langages de programmation respectent en général la structure des transactions SQL.\n",
    "\n",
    "![sql.transaction.png](attachment:sql.transaction.png)\n",
    "\n",
    "Point important :\n",
    "- Durant une connexion, plusieurs transactions peuvent avoir lieu.\n",
    "- Une transaction peut contenir une ou plusieurs requêtes\n",
    "- Une transaction peut être intégralement annulée, ce qui a pour effet d'annuler l'ensemble des requêtes (et donc des INSERT et UPDATE).\n",
    "\n",
    "### Important !\n",
    "\n",
    "Quand vous entreprendrez vos propres projets et que vous travaillerez avec des bases de données:\n",
    "\n",
    "1. Ne jamais travailler directement sur la base de données publique : une erreur est vite arrivée et vous ne voulez pas effacer l'ensemble des données par mégarde...\n",
    "2. Travaillez sur des copies : faites un backup et installez ces données sur votre propre machine\n",
    "3. Privilégiez le lancement de toutes vos requêtes sur des machines hors production (= celles qui ne sont pas utilisées par le public) avant de les faire fonctionner réellement.\n",
    "\n",
    "### MySQL et Python\n",
    "\n",
    "Nous ne couvrons plus ici l'utilisation de MySQL et python de manière brute. Pour plus d'information, vous pouvez aller voir le cour dans sa forme de [2017-2018](https://github.com/PonteIneptique/cours-python/releases/tag/2017-2018).\n",
    "\n",
    "### Installation SQLite\n",
    "\n",
    "**Normalement, SQLite vient avec Mac et Linux Ubuntu par défaut.**\n",
    "\n",
    "Sinon : \n",
    "\n",
    "#### Ubuntu\n",
    "\n",
    "```shell\n",
    "sudo apt-get install sqlite3\n",
    "```\n",
    "\n",
    "#### Mac\n",
    "\n",
    "Installez [homebrew](https://brew.sh/index_fr) puis :\n",
    "\n",
    "```shell\n",
    "brew install sqlite3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SQLAlchemy et Flask_sqlalchemy\n",
    "\n",
    "Pour interagir avec des bases de données SQL, nous recommandons en général l'utilisation de SQLAlchemy et de son adaptation à Flask `flask_sqlalchemy`. Nous ne verrons pas l'intégralité des possibilités de SQLAlchemy pour le moment mais simplement l'utilisation de celui-ci pour interroger une base de données existante.\n",
    "\n",
    "Pour installer le package, nous allons utiliser `pip` et taper dans notre terminal, avec l'environnement virtuel installé, `pip install flask_sqlalchemy==2.3.2` : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install flask_sqlalchemy==2.3.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour utiliser flask-sqlalchemy, il va falloir connecter notre application à la base de données. Pour ce faire, il faut donner à configurer Sql Alchemy : \n",
    "\n",
    "```python\n",
    "from flask import Flask\n",
    "from flask_sqlalchemy import SQLAlchemy\n",
    "\n",
    "app = Flask(\"Nom\")\n",
    "app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///cours-flask/db.sqlite'\n",
    "db = SQLAlchemy(app)\n",
    "```\n",
    "\n",
    "### Commentaire de code :\n",
    "\n",
    "- Nous importons à la fois Flask et SQLAlchemy (Version flask_sqlalchemy)\n",
    "- Nous créons une application Flask qui portera le nom \"Nom\"\n",
    "- Nous configurons l'application avec les informations nécessaires pour se connecter. Vous trouverez l'ensemble des informations dans la partie [configuration](http://flask-sqlalchemy.pocoo.org/2.3/config/) de la documentation de Flask_SQLAlchemy\n",
    "- Nous initions l'objet SQLAlchemy en lui fournissant l'application comme variable et en le stockant dans la variable `db`.\n",
    "- L'adresse de base de données est composée de :\n",
    "    - `sqlite://` qui indique le moteur utilisé\n",
    "    - `/` qui indique pour sqlite l'usage d'un chemin relatif (un chemin absolu est précédé de `//` pour sqlite)\n",
    "    - `cours-flask/db.sqlite` le chemin depuis la racine du cours python jusqu'à la base de données\n",
    "\n",
    "Vu que nous n'exécutons pas le code pour le moment, vous pouvez lancer le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask\n",
    "from flask_sqlalchemy import SQLAlchemy\n",
    "\n",
    "app = Flask(\"Nom\")\n",
    "app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///cours-flask/db.sqlite'\n",
    "db = SQLAlchemy(app)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important:** Vous avez sûrement un avertissement. La documentation de flask_sqlalchemy nous informe que le paramètre `SQLALCHEMY_TRACK_MODIFICATIONS` devrait être désactivé, car il provoque des baisses de performances et qu'il sera supprimé par défaut dans le futur. Nous le conserverons ainsi pour le moment bien que nous ne l'utiliserons pas.\n",
    "\n",
    "### Les requêtes manuelles\n",
    "\n",
    "Pour récupérer des données de la table `place` avec SQLAlchemy, il suffit d'exécuter la sous-méthode `engine.execute()` de `db`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "query = db.engine.execute(\"SELECT * FROM place\")\n",
    "print(query)\n",
    "# Vous pouvez remplacer fetchmany par fetchall ou fetchone en supprimant le 2\n",
    "for x in query.fetchmany(2):\n",
    "    print(x[\"place_nom\"])\n",
    "    print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plusieurs choses nous intéressent ici :\n",
    "- Notre variable `query` est en fait un objet `ResultProxy` qui possèdent diverses méthodes comme `.fetchone()`, `.fetchall()` et `.fetchmany(nombre)`.\n",
    "- Nous pouvons faire une boucle sur le résultat des méthodes `.fetch[COMBIEN]()`\n",
    "- Nos résultats sont en fait des objets `RowProxy` se comportant aussi comme des dictionnaires.\n",
    "- Nos résultats prennent comme clé de dictionnaire les noms des colonnes\n",
    "\n",
    "Cependant, peu de développeurs utilisent SQLAlchemy et sa version Flask pour écrire ce genre de requête..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Générer les requêtes automatiquement : les modèles\n",
    "\n",
    "De fait, il est plus courant pour les développeur-se-s utilisant SQLAlchemy de créer ce que l'on va appeler des modèles. Les modèles sont créés grâce à la déclaration `class` comme suit :\n",
    "\n",
    "```python\n",
    "class Place(db.Model):\n",
    "    # Tout comme tous les deux points de python, on écrit ensuite en décalé\n",
    "```\n",
    "\n",
    "Le nom de la après `class` doit être le même que le nom de la table (avec une majuscule pour l'identifier visuellement plus facilement). On enregistre ensuite les différents champs du modèle avec la syntaxe `nom = colonne(type de colonne, paramètres supplémentaires)`:\n",
    "\n",
    "```python\n",
    "class Place(db.Model):\n",
    "    place_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)\n",
    "```\n",
    "\n",
    "Il existe alors plusieurs types de colonnes :\n",
    "\n",
    "| Type         | Exemple         | Définition                                                                    |\n",
    "| ------------ | --------------- | ------------------------------------------------------------------------------|\n",
    "| Entier       | db.Integer      | Stocke un entier                                                              |\n",
    "| Chaîne       | db.String(42)   | Stocke une chaîne à taille maximale ( ici 42)                                 |\n",
    "| Texte        | db.Text         | Un texte sans taille maximale                                                 |\n",
    "| DateTime     | db.DateTime     | Date et Heure suivant un objet [`datetime`](https://docs.python.org/3.5/library/datetime.html) en python                           |\n",
    "| Float        | db.Float        | Stocke un décimal                                                             |\n",
    "| Boolean      | db.Boolean      | Stocke un booléen                                                             |\n",
    "\n",
    "![Modele pour les images](images/model.place.png)\n",
    "\n",
    "Pour notre classe modèle dont nous recopions l'image ci-dessus, cela signifie que notre code sera :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Place(db.Model):\n",
    "    place_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)\n",
    "    place_nom = db.Column(db.Text)\n",
    "    place_description = db.Column(db.Text)\n",
    "    place_longitude = db.Column(db.Float)\n",
    "    place_latitude = db.Column(db.Float)\n",
    "    place_type = db.Column(db.String(45))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice\n",
    "\n",
    "Réalisez la même chose pour la table utilisateur :\n",
    "\n",
    "![User Model](images/model.user.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Des modèles aux requêtes\n",
    "\n",
    "#### `Select * From Place`\n",
    "Maintenant que notre modèle est mis en place, il est possible de faire des requêtes. Pour récupérer l'intégralité des lieux, nous devons faire `NomDeLaClasseDeDonnées.query.all()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lieux = Place.query.all()\n",
    "print(lieux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Afficher des informations sur un lieu\n",
    "\n",
    "Nous avons donc désormais une liste de lieux issus de la base de données. Peut-être pouvons-nous afficher le nom de chacun d'entre eux. Pour cela, nous allons utiliser les noms de colonnes comme des attributs :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for lieu in lieux:\n",
    "    print(lieu.place_nom, lieu.place_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Select * From Places where place_id = 1`\n",
    "\n",
    "Pour les clés primaires, Flask SqlAlchemy propose l'utilisation de `.query.get(cle)` pour récupérer l'information, en l'occurrence, si l'on voulait retrouver le lieu 5 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cinq = Place.query.get(5)\n",
    "print(cinq.place_nom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Select * From Places where place_type=\"settlement\"`\n",
    "\n",
    "Pour les requêtes plus complexes (avec un champ autre que le champ primaire), on utilise les conditions pythons `==` dans `.query.filter()`. On retrouve ensuite les résultats en utilisant :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "settlements = Place.query.filter(Place.place_type==\"settlement\").all()\n",
    "print(settlements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compter le nombre de résultats\n",
    "\n",
    "Il y a des situations où l'on souhaite simplement compter les résultats pour afficher cette information. On remplacera alors simplement `.all()` par `.count()` :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "settlements = Place.query.filter(Place.place_type==\"settlement\").count()\n",
    "print(settlements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Une expliquation : ce qui se passe derrière tout cela\n",
    "\n",
    "SQL Alchemy est ce que l'on appelle un ORM ([Object-Relational Mapping](https://fr.wikipedia.org/wiki/Mapping_objet-relationnel)). Les ORM ont généralement plusieurs avantages sur l'utilisation de requêtes directement écrites en SQL :\n",
    "\n",
    "- les résultats sont dans des formes faciles à exploiter : il ne s'agit pas de dictionnaire ou de liste, mais d'objet;\n",
    "- les requêtes sont simples à écrire et faciles à comprendre sans avoir de grandes connaissances en SQL;\n",
    "- généralement, ils offrent une compatibilité avec de nombreux systèmes : SQLAlchemy peut se connecter à SQLite, Postgresql, MySQL, Oracle, MS-SQL, Firebird, Sybase, etc. Cela signifie qu'il est possible de changer de système très facilement en changeant simplement la ligne de connexion.\n",
    "\n",
    "Quand on réalise une requête de type `Place.query.filter(Place.place_type==\"settlement\")`, Flask-SQLAlchemy va commencer à construire la requête suivante : `SELECT * FROM Place WHERE place_type=\"settlement\"`. Puis, :\n",
    "- en faisant `.all()` ensuite, il va récupérer l'ensemble des résultats tels quels\n",
    "- en faisant `.count()`, il va modifier la requête en `SELECT COUNT(*) FROM Place where place_type=\"settlement\"` puis l'exécuter\n",
    "- en faisant `.first()`, on récupèrera le premier résultat (et donc on évite une liste)\n",
    "\n",
    "La requête est donc traduite et augmentée au fur et à mesure que nous enchaînons les méthodes.\n",
    "\n",
    "#### Exercice\n",
    "Par exemple, on peut très bien ordonner les objets. Pouvez-vous traduire la ligne suivante en MySQL :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "settlements = Place.query.filter(Place.place_type==\"settlement\").order_by(Place.place_nom.desc()).all()\n",
    "print(settlements)\n",
    "\n",
    "# En SQL :\n",
    "requete = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notez qu'il est possible de récupérer la requête traduire pour la déboguer !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "requete = Place.query.filter(Place.place_type==\"settlement\").order_by(Place.place_nom.desc())\n",
    "\n",
    "# En SQL :\n",
    "print(requete)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Des requêtes à leur utilisation dans une page web\n",
    "\n",
    "Maintenant que nous avons notre modèle, nous pouvons commencer à intégrer ces requêtes. Nous avions jusque là une page index qui affichait l'ensemble des liens de la base de données. Nous allons donc d'abord configurer comme ci-dessus Flask SQL Alchemy :\n",
    "\n",
    "```python\n",
    "\n",
    "from flask import Flask, render_template\n",
    "from flask_sqlalchemy import SQLAlchemy\n",
    "\n",
    "app = Flask(\"Application\")\n",
    "# On configure la base de données\n",
    "app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///cours-flask/db.sqlite'\n",
    "# On initie l'extension\n",
    "db = SQLAlchemy(app)\n",
    "```\n",
    "\n",
    "On copiera ensuite le modèle de données :\n",
    "\n",
    "```python\n",
    "\n",
    "class Place(db.Model):\n",
    "    place_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)\n",
    "    place_nom = db.Column(db.Text)\n",
    "    place_description = db.Column(db.Text)\n",
    "    place_longitude = db.Column(db.Float)\n",
    "    place_latitude = db.Column(db.Float)\n",
    "    place_type = db.Column(db.String(45))\n",
    "```\n",
    "\n",
    "Puis on récupère les données au moment de l'exécution des routes :\n",
    "\n",
    "```python\n",
    "\n",
    "@app.route(\"/\")\n",
    "def accueil():\n",
    "    # On a bien sûr aussi modifié le template pour refléter le changement\n",
    "    lieux = Place.query.all()\n",
    "    return render_template(\"pages/accueil.html\", nom=\"Gazetteer\", lieux=lieux)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice\n",
    "\n",
    "**Avant de regarder l'exemple 11 ci-dessous**, essayez de modifier la route ci-dessous afin qu'elle utilise la connexion à la base de données :\n",
    "\n",
    "```python\n",
    "@app.route(\"/place/<int:place_id>\")\n",
    "def lieu(place_id):\n",
    "    return render_template(\"pages/place.html\", nom=\"Gazetteer\", lieu=lieux[place_id])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemple 11\n",
    "\n",
    "- [Nouveau template pour l'accueil](cours-flask/exemple11/templates/pages/accueil.html)\n",
    "- [Nouveau template pour les lieux](cours-flask/exemple11/templates/pages/place.html)\n",
    "\n",
    "Dans votre terminal, avec votre environnement virtuel :\n",
    "\n",
    "```sh\n",
    "cd cours-flask/exemple11\n",
    "python app.py\n",
    "```\n",
    "\n",
    "puis allez sur http://127.0.0.1:5000"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}