Projet_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Projet Maison 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# import des modules usuels\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# options d'affichage\n",
    "pd.set_option(\"display.min_rows\", 16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# chargement et traitement des données\n",
    "GEO = pd.read_csv(\"correspondance-code-insee-code-postal.csv\",\n",
    "                   sep=';',\n",
    "                   usecols=range(11),\n",
    "                   index_col=\"Code INSEE\")\n",
    "\n",
    "# A COMPLETER avec les colonnes\n",
    "# - lat, lon : latitude et longitude des communes\n",
    "# - cp_ville : Code Postal + \" \" + \"Commune\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "GEO[['lat', 'lon']] = GEO[\"geo_point_2d\"].str.extract(\"(.*), (.*)\").astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Code Postal</th>\n",
       "      <th>Commune</th>\n",
       "      <th>Département</th>\n",
       "      <th>Région</th>\n",
       "      <th>Statut</th>\n",
       "      <th>Altitude Moyenne</th>\n",
       "      <th>Superficie</th>\n",
       "      <th>Population</th>\n",
       "      <th>geo_point_2d</th>\n",
       "      <th>geo_shape</th>\n",
       "      <th>lat</th>\n",
       "      <th>lon</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Code INSEE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>31080</th>\n",
       "      <td>31350</td>\n",
       "      <td>BOULOGNE-SUR-GESSE</td>\n",
       "      <td>HAUTE-GARONNE</td>\n",
       "      <td>MIDI-PYRENEES</td>\n",
       "      <td>Chef-lieu canton</td>\n",
       "      <td>301.0</td>\n",
       "      <td>2470.0</td>\n",
       "      <td>1.6</td>\n",
       "      <td>43.2904403081, 0.650641474176</td>\n",
       "      <td>{\"type\": \"Polygon\", \"coordinates\": [[[0.671852...</td>\n",
       "      <td>43.29044</td>\n",
       "      <td>0.650641</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Code Postal             Commune    Département         Région  \\\n",
       "Code INSEE                                                                 \n",
       "31080            31350  BOULOGNE-SUR-GESSE  HAUTE-GARONNE  MIDI-PYRENEES   \n",
       "\n",
       "                      Statut  Altitude Moyenne  Superficie  Population  \\\n",
       "Code INSEE                                                               \n",
       "31080       Chef-lieu canton             301.0      2470.0         1.6   \n",
       "\n",
       "                             geo_point_2d  \\\n",
       "Code INSEE                                  \n",
       "31080       43.2904403081, 0.650641474176   \n",
       "\n",
       "                                                    geo_shape       lat  \\\n",
       "Code INSEE                                                                \n",
       "31080       {\"type\": \"Polygon\", \"coordinates\": [[[0.671852...  43.29044   \n",
       "\n",
       "                 lon  \n",
       "Code INSEE            \n",
       "31080       0.650641  "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GEO.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "GEO['cp_ville'] = GEO['Code Postal'] + ' ' + GEO['Commune']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Code Postal</th>\n",
       "      <th>Commune</th>\n",
       "      <th>Département</th>\n",
       "      <th>Région</th>\n",
       "      <th>Statut</th>\n",
       "      <th>Altitude Moyenne</th>\n",
       "      <th>Superficie</th>\n",
       "      <th>Population</th>\n",
       "      <th>geo_point_2d</th>\n",
       "      <th>geo_shape</th>\n",
       "      <th>lat</th>\n",
       "      <th>lon</th>\n",
       "      <th>cp_ville</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Code INSEE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>31080</th>\n",
       "      <td>31350</td>\n",
       "      <td>BOULOGNE-SUR-GESSE</td>\n",
       "      <td>HAUTE-GARONNE</td>\n",
       "      <td>MIDI-PYRENEES</td>\n",
       "      <td>Chef-lieu canton</td>\n",
       "      <td>301.0</td>\n",
       "      <td>2470.0</td>\n",
       "      <td>1.6</td>\n",
       "      <td>43.2904403081, 0.650641474176</td>\n",
       "      <td>{\"type\": \"Polygon\", \"coordinates\": [[[0.671852...</td>\n",
       "      <td>43.29044</td>\n",
       "      <td>0.650641</td>\n",
       "      <td>31350 BOULOGNE-SUR-GESSE</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Code Postal             Commune    Département         Région  \\\n",
       "Code INSEE                                                                 \n",
       "31080            31350  BOULOGNE-SUR-GESSE  HAUTE-GARONNE  MIDI-PYRENEES   \n",
       "\n",
       "                      Statut  Altitude Moyenne  Superficie  Population  \\\n",
       "Code INSEE                                                               \n",
       "31080       Chef-lieu canton             301.0      2470.0         1.6   \n",
       "\n",
       "                             geo_point_2d  \\\n",
       "Code INSEE                                  \n",
       "31080       43.2904403081, 0.650641474176   \n",
       "\n",
       "                                                    geo_shape       lat  \\\n",
       "Code INSEE                                                                \n",
       "31080       {\"type\": \"Polygon\", \"coordinates\": [[[0.671852...  43.29044   \n",
       "\n",
       "                 lon                  cp_ville  \n",
       "Code INSEE                                      \n",
       "31080       0.650641  31350 BOULOGNE-SUR-GESSE  "
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GEO.head(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Partie A**\n",
    "\n",
    "- Compléter le chargement des données en ajoutant au dataframe `GEO`\n",
    "    - les colonnes \"lat\" et \"lon\" avec la latitude et la longitude des communes\n",
    "    - une colonne \"cp_ville\" avec le Code Postal + un espace + et le nom de la Commune\n",
    "- Ecrire une fonction `search_city(lat, lon)` qui retourne le \"cp_ville\" de la commune la plus proche d'un point à partir de sa latitude et sa longitude.\n",
    "- Ecrire une fonction `dms2dec(deg, min, sec)` qui convertit les degrés, minutes, secondes en valeur numérique pour pouvoir utiliser la fonction précédente avec un GPS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# fonction recherche de ville\n",
    "def search_city(lat, long):\n",
    "    return GEO.loc[((lat - GEO['lat'])**2 + (long - GEO['lon'])**2).idxmin()]['cp_ville']    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# conversion degrés, minutes, secondes => décimal\n",
    "def dms2dec(deg, mn, sec):\n",
    "    return deg + mn/60 + sec/3600    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'71330 BOSJEAN'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on applique la fonction à une coordonnée tirée au hasard\n",
    "np.random.seed(0)\n",
    "a, b = 41.5, 51.1  # latitude min et max de la France métropolitaine\n",
    "lat = np.random.uniform(a, b)\n",
    "a, b = -5.1, 9.5  # longitude min et max de la France métropolitaine\n",
    "lon = np.random.uniform(a, b)\n",
    "\n",
    "search_city(lat, lon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'91120 PALAISEAU'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# à partir de coordonnées GPS précises\n",
    "search_city(dms2dec(48, 42, 52), dms2dec(2, 14, 45))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Partie B**\n",
    "\n",
    "La colonne \"geo_shape\" comporte des chaines de catactères au format JSON. Elles représentent les formes géométriques des communes qui sont soit des polygones soit composées de plusieurs polygones.\n",
    "\n",
    "- Utiliser la librairie Python **json** pour parser les valeurs de la colonne \"geo_shape\" et mettre le résultat (`Series`) dans la variable `GEO_SHAPE`.\n",
    "- Ecrire une fonction `get_types()` qui retourne le décompte (`value_counts()`) des valeurs accédées avec la clé \"type\".\n",
    "- Ecrire une fonction `get_coordinates_len()` qui retourne le décompte (`value_counts()`) des longueurs des listes accédées avec la clé \"coordinates\".\n",
    "- Ecrire une fonction `get_most_complex_city()` qui retourne la commune est constituée du plus grand nombre de polygones ?\n",
    "- Ecrire une fonction `get_nb_cities_2_polygons()` qui retourne  le nombre de villes qui sont de type \"Polygon\" mais dont la longueur des listes accédées avec la clé \"coordinates\" vaut 2 ?\n",
    "- **Facultatif :**\n",
    "- Pour ces villes vérifier que le premier polygone contient bien le second (enclave). NB : on pourra installer la librairie **shapely**, utiliser la classe Polygon de **shapely.geometry**  et la méthode `contains()`. Sur Windows **shapely** peut nécessiter d'installer manuellement la dll \"geos_c.dll\" dans le répertoire \"Library/bin\" de votre environnement Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>coordinates</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Code INSEE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>31080</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[0.671852008023359, 43.268343740258835], [0....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11143</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[2.906996888482618, 42.895679017325214], [2....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43028</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[4.091674013520042, 45.10387299771701], [4.0...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78506</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[1.82961019583912, 48.496571987531524], [1.8...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>84081</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[4.927176726246697, 43.90528366187598], [4.8...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80462</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[1.849459801983121, 50.17500092547019], [1.8...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40200</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[-0.710168187746476, 44.34474055229595], [-0...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17394</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[-0.66124517570293, 46.112107175022146], [-0...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15024</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[2.302124109031132, 45.19200821045956], [2.2...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76008</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[1.205457180575811, 49.8846111948466], [1.16...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>02137</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[3.258096611944434, 49.05600500728458], [3.2...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74066</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[6.026228645474093, 46.0398190939394], [6.01...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>67315</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[8.106826841916497, 48.94076044446545], [8.0...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>07122</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[4.356584796725173, 44.54080039174845], [4.3...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>01026</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[4.926593676348706, 46.304132622674715], [4....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50224</th>\n",
       "      <td>Polygon</td>\n",
       "      <td>[[[-0.997539314886753, 48.950278285217586], [-...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>36742 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               type                                        coordinates\n",
       "Code INSEE                                                            \n",
       "31080       Polygon  [[[0.671852008023359, 43.268343740258835], [0....\n",
       "11143       Polygon  [[[2.906996888482618, 42.895679017325214], [2....\n",
       "43028       Polygon  [[[4.091674013520042, 45.10387299771701], [4.0...\n",
       "78506       Polygon  [[[1.82961019583912, 48.496571987531524], [1.8...\n",
       "84081       Polygon  [[[4.927176726246697, 43.90528366187598], [4.8...\n",
       "80462       Polygon  [[[1.849459801983121, 50.17500092547019], [1.8...\n",
       "40200       Polygon  [[[-0.710168187746476, 44.34474055229595], [-0...\n",
       "17394       Polygon  [[[-0.66124517570293, 46.112107175022146], [-0...\n",
       "...             ...                                                ...\n",
       "15024       Polygon  [[[2.302124109031132, 45.19200821045956], [2.2...\n",
       "76008       Polygon  [[[1.205457180575811, 49.8846111948466], [1.16...\n",
       "02137       Polygon  [[[3.258096611944434, 49.05600500728458], [3.2...\n",
       "74066       Polygon  [[[6.026228645474093, 46.0398190939394], [6.01...\n",
       "67315       Polygon  [[[8.106826841916497, 48.94076044446545], [8.0...\n",
       "07122       Polygon  [[[4.356584796725173, 44.54080039174845], [4.3...\n",
       "01026       Polygon  [[[4.926593676348706, 46.304132622674715], [4....\n",
       "50224       Polygon  [[[-0.997539314886753, 48.950278285217586], [-...\n",
       "\n",
       "[36742 rows x 2 columns]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import json\n",
    "GEO_SHAPE = GEO['geo_shape'].apply(json.loads).apply(pd.Series)\n",
    "GEO_SHAPE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GEO_SHAPE\n",
    "# La variable GEO_SHAPE doit contenir une Serie\n",
    "# correspondant aux valeurs de la colonne \"geo_shape\" parsées avec la librairie json\n",
    "#GEO_SHAPE = pd.Series(dtype=object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GEO_SHAPE['type'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataframe = GEO_SHAPE['coordinates'].apply(lambda x: np.array(x, dtype = object)).apply(lambda y: np.shape(y)[0])\n",
    "dataframe.loc[GEO_SHAPE[GEO_SHAPE['type'] == 'Polygon'].index][dataframe == 2].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# value_counts des valeurs \"type\"\n",
    "def get_types():\n",
    "    return GEO_SHAPE['type'].value_counts()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# value_counts des longueurs de \"coordinates\"\n",
    "def get_coordinates_len():\n",
    "    dataframe = GEO_SHAPE['coordinates'].apply(lambda x: np.array(x, dtype = object)).apply(lambda y: np.shape(y)[0])\n",
    "    return dataframe.value_counts()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# commune constituée du plus grand nombre de polygones\n",
    "def get_most_complex_city():\n",
    "    dataframe = GEO_SHAPE['coordinates'].apply(lambda x: np.array(x, dtype = object)).apply(lambda y: np.shape(y)[0])\n",
    "    return GEO.loc[dataframe.idxmax()]['cp_ville']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# commune constituée du plus grand nombre de polygones\n",
    "def get_nb_cities_2_polygons():\n",
    "    dataframe = GEO_SHAPE['coordinates'].apply(lambda x: np.array(x, dtype = object)).apply(lambda y: np.shape(y)[0])\n",
    "    return dataframe.loc[GEO_SHAPE[GEO_SHAPE['type'] == 'Polygon'].index][dataframe == 2].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tests\n",
    "import unittest\n",
    "\n",
    "class Session2Test(unittest.TestCase):\n",
    "    \n",
    "    def test_partie_A1(self):\n",
    "        # on applique la fonction cherche_ville() à une coordonnée tirée au hasard\n",
    "        np.random.seed(0)\n",
    "        a, b = 41.5, 51.1  # latitude min et max de la France métropolitaine\n",
    "        lat = np.random.uniform(a, b)\n",
    "        a, b = -5.1, 9.5  # longitude min et max de la France métropolitaine\n",
    "        lon = np.random.uniform(a, b)\n",
    "\n",
    "        cp_ville = search_city(lat, lon)\n",
    "        self.assertEqual(cp_ville, \"71330 BOSJEAN\")\n",
    "        \n",
    "    def test_partie_A2(self):\n",
    "        # à partir de coordonnées GPS précises\n",
    "        cp_ville = search_city(dms2dec(48, 42, 52), dms2dec(2, 14, 45))\n",
    "        self.assertEqual(cp_ville, \"91120 PALAISEAU\")\n",
    "        \n",
    "    def test_partie_B1(self):\n",
    "        # check types\n",
    "        dico = get_types()\n",
    "        self.assertEqual(dico[\"Polygon\"], 36670)\n",
    "        self.assertEqual(dico[\"MultiPolygon\"], 72)\n",
    "        \n",
    "    def test_partie_B2(self):\n",
    "        # check coordinates len\n",
    "        dico = get_coordinates_len()\n",
    "        self.assertEqual(dico[1], 36660)\n",
    "        self.assertEqual(dico[2], 80)\n",
    "       \n",
    "    def test_partie_B3(self):\n",
    "        # check most complex city\n",
    "        cp_ville = get_most_complex_city()\n",
    "        self.assertEqual(cp_ville, \"83400 HYERES\")\n",
    "        \n",
    "    def test_partie_B4(self):\n",
    "        # check nb cities 2 polygons\n",
    "        nb = get_nb_cities_2_polygons()\n",
    "        self.assertEqual(nb, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_partie_A1 (__main__.Session2Test) ... ok\n",
      "test_partie_A2 (__main__.Session2Test) ... ok\n",
      "test_partie_B1 (__main__.Session2Test) ... ok\n",
      "test_partie_B2 (__main__.Session2Test) ... ok\n",
      "test_partie_B3 (__main__.Session2Test) ... ok\n",
      "test_partie_B4 (__main__.Session2Test) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 6 tests in 2.013s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# run tests\n",
    "def run_tests():\n",
    "    test_suite = unittest.makeSuite(Session2Test)\n",
    "    runner = unittest.TextTestRunner(verbosity=2)\n",
    "    runner.run(test_suite)\n",
    "    \n",
    "run_tests()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}