appMAP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "$('#header').toggle();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, Javascript\n",
    "popup = Javascript(\"\"\"\n",
    "require(\n",
    "    [\"base/js/dialog\"], \n",
    "    function(dialog) {\n",
    "        dialog.modal({\n",
    "            title: 'Je cherche vos destinations, merci de patienter quelques secondes',\n",
    "            body: \"L'import peut prendre plusieurs dizaines de secondes, mais vous n'aurez pas besoin de le repeter tant que vous ne validez pas de nouvelle adresse en haut de la carte.\",\n",
    "        });\n",
    "    }\n",
    ");\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing as mp\n",
    "from multiprocessing.dummy import  Pool\n",
    "from functools import partial\n",
    "import numpy as np\n",
    "\n",
    "def parallelize(data, func, num_of_processes=mp.cpu_count()):\n",
    "    data_split = np.array_split(data, num_of_processes)\n",
    "    pool = Pool(num_of_processes)\n",
    "    data = pd.concat(pool.map(func, data_split))\n",
    "    pool.close()\n",
    "    pool.join()\n",
    "    return data\n",
    "\n",
    "def run_on_subset(func, data_subset):\n",
    "    return data_subset.apply(func)\n",
    "\n",
    "def parallelize_on_rows(data, func, num_of_processes=mp.cpu_count()):\n",
    "    return parallelize(data, partial(run_on_subset, func), num_of_processes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "from ipyleaflet import Map, basemaps, basemap_to_tiles, Heatmap, Circle, Polyline\n",
    "from ipywidgets import HTML, Label, Valid, Combobox, Dropdown, Text, Button, IntText, VBox, HBox, Box\n",
    "from ipywidgets import Layout, AppLayout, GridspecLayout\n",
    "from geopy import Point\n",
    "from geopy.geocoders import Nominatim, BANFrance\n",
    "from geopy.distance import geodesic\n",
    "\n",
    "\n",
    "maps = {'Standard' : basemaps.OpenStreetMap.Mapnik}\n",
    "basemap_selector_value = 'Standard'\n",
    "\n",
    "countries_file = 'sql-pays.csv'\n",
    "state = sorted(list(pd.read_csv(countries_file, sep=',', low_memory=False, header=None)[4]))\n",
    "\n",
    "df_dep=pd.read_csv('frGEO_dep.csv.gz', compression='gzip', sep=',', low_memory=False)\n",
    "\n",
    "geolocator = Nominatim(user_agent=\"appMAP_cernicchiaro.giulia@gmail.com\")\n",
    "geolocator_fr = BANFrance()\n",
    "\n",
    "\n",
    "glb = {'curr_locs' : {},\n",
    "       'pane_heights' : ['15%', '35%', '45%'],\n",
    "       'radius_selector_value' : 100,\n",
    "       'center_location' : None,\n",
    "       'cur_address_df' : {},\n",
    "       'cur_children_len' : -2,\n",
    "       'info_rows' : [],\n",
    "       'log_rows' : []\n",
    "      }\n",
    "\n",
    "\n",
    "header = HTML(\"<h2>GPS à Vol d'Oiseaux</h2>\", layout=Layout(height='auto'))\n",
    "header.style.text_align='center'\n",
    "\n",
    "state_selector = Dropdown( options = list(state), layout=Layout(width='auto'), value = 'France' )\n",
    "\n",
    "radius_selector = IntText(value=100, layout=Layout(width='auto'))\n",
    "\n",
    "subheader_1 = HTML(\n",
    "    value='<h3>Adresse choisie</h3>',\n",
    "    layout=Layout(width='auto', height='auto')\n",
    ")\n",
    "\n",
    "user_search = Combobox(placeholder='Saisir une adresse et cherhcer OU cliquer sur la carte', options=[])\n",
    "user_search.layout.width = '90%'\n",
    "\n",
    "user_action = Button(description='Chercher', button_style='info', tooltip=\"Geolocaliser l'adresse saisie\")\n",
    "\n",
    "subheader_2 = HTML(\n",
    "    value='<h4>Adresses Trouvées</h4>',\n",
    "    layout=Layout(width='auto', height='auto')\n",
    ")\n",
    "\n",
    "address_selector = Dropdown()\n",
    "address_selector.layout.width = '98%'\n",
    "\n",
    "main_map = Map(basemap=basemaps.OpenStreetMap.Mapnik)\n",
    "main_map.layout.height = 'auto'\n",
    "center_map = geolocator.geocode(state_selector.value)\n",
    "main_map.center = (center_map.latitude, center_map.longitude)\n",
    "main_map.zoom = 6\n",
    "\n",
    "circle = Circle()\n",
    "circle_radius = Circle()\n",
    "\n",
    "subheader_3 = HTML(\n",
    "    value='<h3>Verifier une Adresse</h3>',\n",
    "    layout=Layout(width='auto', height='auto')\n",
    ")\n",
    "\n",
    "user_verify = Combobox(placeholder=\"Saisir une adresse à verifier à vol d'oiseau\", options=[])\n",
    "user_verify.layout.width = '90%'\n",
    "\n",
    "user_action_2 = Button(description='Verifier', button_style='info', tooltip=\"\")\n",
    "\n",
    "resume_destinations_head = HTML(value = '<h3>Resumé des Destinations à '+str(glb['radius_selector_value'])+'km</h3>')\n",
    "list_destinations_head = HTML('<h4>Chercher par Departement</h4>')\n",
    "\n",
    "resume_destinations = HTML(\n",
    "    value='',\n",
    "    layout=Layout(width='auto', height='auto')\n",
    ")\n",
    "\n",
    "dep_selector = Dropdown()\n",
    "dep_selector.options = list([' - '])\n",
    "\n",
    "com_selector = Dropdown()\n",
    "com_selector.options = list([' - '])\n",
    "\n",
    "adr_selector = Dropdown()\n",
    "adr_selector.options = list([' - '])\n",
    "\n",
    "out = HTML(\n",
    "    value='',\n",
    "    layout=Layout(width='auto', height='auto')\n",
    ")\n",
    "\n",
    "grid_header = GridspecLayout(1, 4, height='auto')\n",
    "grid_header[0, :3] = header\n",
    "grid_header[0, 3:] = VBox([Label(\"Pays : \"),state_selector,Label(\"Rayon (km) : \"),radius_selector])\n",
    "\n",
    "vbox_header = VBox([grid_header,\n",
    "                    subheader_1,\n",
    "                    HBox([user_search,user_action]),\n",
    "                   ])\n",
    "\n",
    "grid_destinations = GridspecLayout(7, 2, height='auto')\n",
    "grid_destinations[1,0:1] = HTML(value = '<h2>Module Special</h2>')\n",
    "grid_destinations[2, 0] = resume_destinations_head\n",
    "grid_destinations[2, 1] = list_destinations_head\n",
    "grid_destinations[3:, 0] = resume_destinations\n",
    "grid_destinations[3:, 1] = HBox([dep_selector,com_selector,adr_selector])\n",
    "\n",
    "vbox_footer = VBox([out])\n",
    "\n",
    "waiting_panel = HTML('<img src=\"giphy.gif\">')\n",
    "\n",
    "\n",
    "app_display = AppLayout(header=vbox_header,\n",
    "                        center=main_map,\n",
    "                        footer=vbox_footer,\n",
    "                        pane_heights=glb['pane_heights'],\n",
    "                        height='2000px',\n",
    "                        grid_gap=\"1px\")\n",
    "\n",
    "\n",
    "def toggle_display(cur_display):\n",
    "    if cur_display == 'wait':\n",
    "        app_display.header = None\n",
    "        app_display.center = waiting_panel\n",
    "        app_display.footer = None\n",
    "        app_display.height='auto'\n",
    "    elif cur_display == 'app':\n",
    "        app_display.header = vbox_header\n",
    "        app_display.center = main_map\n",
    "        app_display.footer = vbox_footer\n",
    "        app_display.height='2000px'\n",
    "\n",
    "def is_in(dt):\n",
    "    return geodesic(dt,glb['center_location'].point).km <= glb['radius_selector_value']\n",
    "\n",
    "def get_in_deps(loc):\n",
    "    return set([x['dep'] for i,x in df_dep.iterrows() if geodesic((x['lat'],x['lon']),(loc.latitude,loc.longitude)).km <= glb['radius_selector_value']])\n",
    "\n",
    "def get_in_address(d,full=False):\n",
    "    file = 'ban-'+d+'.csv.gz'\n",
    "    df=pd.read_csv(file, compression='gzip', sep=',', low_memory=False)\n",
    "    if(full):\n",
    "        return df\n",
    "    else:\n",
    "        return df[parallelize_on_rows(df[['lat','lon']].apply(lambda x: Point(x['lat'],x['lon']),axis=1), is_in)]\n",
    "\n",
    "def get_cur_addressdetails(adr):\n",
    "    local_log = 'Details selection : '\n",
    "    if 'properties' in adr.raw.keys() :\n",
    "        cnt = 'France'\n",
    "        dep = adr.raw['properties']['postcode'][:2]\n",
    "        com = adr.raw['properties']['postcode']\n",
    "        local_log += 'BAN '\n",
    "        local_log += ' - '.join([cnt,dep,com])\n",
    "    elif 'address' in adr.raw.keys() :\n",
    "        cnt = adr.raw['address']['country']\n",
    "        if cnt == 'France' :\n",
    "            dep = adr.raw['address']['postcode'][:2]\n",
    "            com = adr.raw['address']['postcode']\n",
    "            local_log += 'OSM '\n",
    "            local_log += ' - '.join([cnt,dep,com])\n",
    "        else :\n",
    "            dep = None\n",
    "            com = None\n",
    "            local_log += cnt\n",
    "    else :\n",
    "        cnt = None\n",
    "        dep = None\n",
    "        com = None\n",
    "        local_log += '[Erreur inattendu]'\n",
    "    return cnt,dep,com,local_log\n",
    "\n",
    "def add_info(msg,level):\n",
    "    cur_rows=glb['info_rows'][:]\n",
    "    glb['info_rows'] = []\n",
    "    for lv in range(level):\n",
    "        glb['info_rows'].append(cur_rows[lv])\n",
    "    glb['info_rows'].append(msg)\n",
    "    msg_to_add = '<h4>'+glb['info_rows'][0]+'</h4>'\n",
    "    if level > 0 :\n",
    "        msg_to_add += '<ul>{}</ul>'.format('<li>'.join([''] + glb['info_rows'][1:]))\n",
    "    return msg_to_add\n",
    "\n",
    "def add_log(msg):\n",
    "    max_rows = 5\n",
    "    glb['log_rows'].append(msg)\n",
    "    if len(glb['log_rows']) > max_rows:\n",
    "        glb['log_rows'].pop(0)\n",
    "    out_rows=glb['log_rows'][:]\n",
    "    out_rows.reverse()\n",
    "    return '<h2>Activity log</h2><ul>{}</ul>'.format('<li>'.join([''] + out_rows))\n",
    "\n",
    "def result_source(inl,inl_fr):\n",
    "    if inl and inl_fr :\n",
    "        out = {l.address:l for l in inl if l.address}\n",
    "        out_fr = {l.address:l for l in inl_fr if l.address}\n",
    "        if len(out)+len(out_fr) == 0:\n",
    "            out_type = None\n",
    "        elif len(out) == 0:\n",
    "            out_type = 'BAN'\n",
    "        elif len(out_fr) == 0:\n",
    "            out_type = 'noBAN'\n",
    "        else:\n",
    "            out_type = 'mixte'\n",
    "    elif inl_fr :\n",
    "        out = {}\n",
    "        out_fr = {l.address:l for l in inl_fr if l.address}\n",
    "        if len(out_fr) == 0:\n",
    "            out_type = None\n",
    "        else:\n",
    "            out_type = 'BAN'\n",
    "    elif inl :\n",
    "        out = {l.address:l for l in inl if l.address}\n",
    "        out_fr = {}\n",
    "        if len(out) == 0:\n",
    "            out_type = None\n",
    "        else:\n",
    "            out_type = 'noBAN'\n",
    "    else :\n",
    "        out = {}\n",
    "        out_fr = {}\n",
    "        out_type = None\n",
    "    return out,out_fr,out_type\n",
    "\n",
    "def search_address(locs,locs_fr,from_button) :\n",
    "    glb['curr_locs'] = {}\n",
    "    msg_add = ' -> '\n",
    "    ladd,ladd_fr,loc_type = result_source(locs,locs_fr)\n",
    "    if loc_type:\n",
    "        if loc_type == 'BAN':\n",
    "            curr_state = 'France'\n",
    "            glb['curr_locs'].update(ladd_fr)\n",
    "        else :\n",
    "            srch_country = set( [l.raw['address']['country'] for l in ladd.values()] )\n",
    "            if state_selector.value in srch_country:\n",
    "                curr_state = state_selector.value\n",
    "            elif loc_type == 'mixte' and 'France' in srch_country:\n",
    "                curr_state = 'France'\n",
    "            elif len(srch_country) == 1 :\n",
    "                curr_state = list(srch_country)[0]\n",
    "            else :\n",
    "                curr_state = ladd[list(ladd.keys())[0]].raw['address']['country']\n",
    "            if curr_state == 'France' :\n",
    "                glb['curr_locs'].update(ladd_fr)\n",
    "                glb['curr_locs'].update({k:v for k,v in ladd.items() if v.raw['address']['country'] == curr_state and k not in ladd_fr.keys()})\n",
    "                glb['curr_locs'].update({k:v for k,v in ladd.items() if v.raw['address']['country'] != curr_state and k not in ladd_fr.keys()})\n",
    "            else:\n",
    "                glb['curr_locs'].update({k:v for k,v in ladd.items() if v.raw['address']['country'] == curr_state and k not in ladd_fr.keys()})\n",
    "                glb['curr_locs'].update({k:v for k,v in ladd.items() if v.raw['address']['country'] != curr_state and v.raw['address']['country'] != 'France' and k not in ladd_fr.keys()})\n",
    "                glb['curr_locs'].update({k:v for k,v in ladd.items() if v.raw['address']['country'] == 'France' and k not in ladd_fr.keys()})\n",
    "                glb['curr_locs'].update(ladd_fr)                \n",
    "        address_selector.options = list(['']+list(glb['curr_locs'].keys()))\n",
    "        if curr_state in state_selector.options :\n",
    "            state_selector.value = curr_state\n",
    "        else :\n",
    "            out.value = add_log('( %s [WARNING] ) %s : pays non disponible dans la liste \\n' % (datetime.now(), curr_state))\n",
    "        first_loc = glb['curr_locs'][list(glb['curr_locs'].keys())[0]]\n",
    "        circle.location = (first_loc.latitude, first_loc.longitude)\n",
    "        circle.radius = 1\n",
    "        circle.color = \"blue\"\n",
    "        main_map.layers = [basemap_to_tiles(maps[basemap_selector_value]), circle]\n",
    "        circle_radius.location = (0, 0)\n",
    "        circle_radius.radius = 0\n",
    "        if len(glb['curr_locs']) == 1 :\n",
    "            vbox_header.children = tuple(list(vbox_header.children)[:3])\n",
    "            user_search.placeholder = 'Saisir une adresse et cherhcer OU cliquer sur la carte'\n",
    "            user_search.value = first_loc.address\n",
    "            msg_add += 'Adresse unique trouvée : ' + str(first_loc.address)\n",
    "        elif len(glb['curr_locs']) > 1 :\n",
    "            vbox_header.children = tuple(list(vbox_header.children)[:3] + [subheader_2, Box([address_selector])])\n",
    "            user_search.placeholder = 'Choisir une adresse parmi celles trouvées OU Chercher une autre adresse'\n",
    "            user_search.value = ''\n",
    "            for l in [v for k,v in glb['curr_locs'].items() if k != list(glb['curr_locs'].keys())[0]] :\n",
    "                main_map.add_layer(Circle(location=(l.latitude, l.longitude),radius=1,color=\"blue\"))\n",
    "            msg_add += str(len(glb['curr_locs'])) + ' adresses trouvées'\n",
    "        if loc_type == 'BAN':\n",
    "            msg_add += ' ( Source : BANFrance )'\n",
    "        elif loc_type == 'noBAN' :\n",
    "            msg_add += ' ( Source : OpenStreetMap )'\n",
    "        elif curr_state == 'France' :\n",
    "            msg_add += ' ( Sources : BANFrance & OpenStreetMap )'\n",
    "        else:\n",
    "            msg_add += ' ( Sources : OpenStreetMap & BANFrance )'\n",
    "        user_action.description = 'Valider'\n",
    "        vbox_footer.children = tuple([list(vbox_footer.children)[-1]])\n",
    "    else :\n",
    "        address_selector.options = list([''])\n",
    "        vbox_header.children = tuple(list(vbox_header.children)[:3])\n",
    "        if from_button :\n",
    "            src_plch = 'pour ' + user_search.value\n",
    "        else :\n",
    "            src_plch = \"à l'endroit cliqué\"\n",
    "        user_search.placeholder = 'Aucun resultat ' + src_plch + '. Ressayer'\n",
    "        user_search.value = ''\n",
    "        msg_add += '[ERROR] Aucune adresse trouvée'\n",
    "        if locs or locs_fr:\n",
    "            msg_add += ' ( Resultats sans adresse :'\n",
    "            if locs :\n",
    "                msg_add += ' BANFrance'\n",
    "            if locs_fr :\n",
    "                msg_add += ' OpenStreetMap'\n",
    "            msg_add += ' )'\n",
    "    return msg_add\n",
    "\n",
    "\n",
    "def on_state_selected(change):\n",
    "    if (geolocator.geocode(state_selector.value, language='fr')):\n",
    "        center_map = geolocator.geocode(state_selector.value)\n",
    "        main_map.center = (center_map.latitude, center_map.longitude)\n",
    "        main_map.zoom = 6\n",
    "        msg = '( %s ) Pays selectioné : %s \\n' % (datetime.now(), state_selector.value)    \n",
    "    else:\n",
    "        msg = '( %s [ERROR] ) %s : pays non disponible \\n' % (datetime.now(), state_selector.value)    \n",
    "    out.value = add_log(msg)\n",
    "\n",
    "def on_radius_selected(change):\n",
    "    #if user_action.description == 'Chercher' and len(main_map.layers) == 3 and main_map.layers[-1].radius > 0 :\n",
    "    #    main_map.layers[-1].radius=radius_selector.value\n",
    "    #    msg = '( %s ) Changement du radius : %s km \\n' % (datetime.now(), radius_selector.value)    \n",
    "    #else:\n",
    "    #    msg = '( %s ) Aucun radius à modifier \\n' % (datetime.now())    \n",
    "    if circle_radius.radius > 0 and radius_selector.value > 0 :\n",
    "        circle_radius.radius = radius_selector.value*1000\n",
    "    #out.value = add_log(msg)\n",
    "\n",
    "def on_text_entry(change):\n",
    "    if user_search.value != '' :\n",
    "        if user_search.value not in address_selector.options :\n",
    "            user_action.description = 'Chercher'\n",
    "            msg = '( %s ) Nouvelle recherche \\n' % (datetime.now())    \n",
    "        else :\n",
    "            user_action.description = 'Valider'\n",
    "            msg = '( %s ) Recherche à valider \\n' % (datetime.now())    \n",
    "        #out.value = add_log(msg)\n",
    "\n",
    "def on_button_clicked(b):\n",
    "    if user_search.value != '' :\n",
    "        user_search.options = tuple(list(set(list(user_search.options) + [user_search.value])))\n",
    "        if user_action.description == 'Chercher':\n",
    "            msg = '( %s ) Adresse saisie : %s \\n' % (datetime.now(), user_search.value)\n",
    "            msg += search_address(geolocator.geocode(user_search.value,exactly_one=False,limit=100,addressdetails=True,language='fr'),\n",
    "                                  geolocator_fr.geocode(user_search.value,exactly_one=False,limit=10),\n",
    "                                  True\n",
    "                                 )\n",
    "        elif user_action.description == 'Valider':\n",
    "            user_verify.options = tuple(list(set(list(user_verify.options) + [user_search.value])))\n",
    "            msg = '( %s ) Adresse validée : %s \\n' % (datetime.now(), user_search.value)    \n",
    "            found_address = glb['curr_locs'][user_search.value]\n",
    "            glb['curr_locs'] = {}\n",
    "            address_selector.options = list([''])\n",
    "            circle.location = (found_address.latitude, found_address.longitude)\n",
    "            circle.radius = 1\n",
    "            circle.color = \"blue\"\n",
    "            main_map.layers = [basemap_to_tiles(maps[basemap_selector_value]), circle]\n",
    "            circle_radius.location = (found_address.latitude, found_address.longitude)\n",
    "            circle_radius.radius = radius_selector.value*1000\n",
    "            circle_radius.color = \"red\"\n",
    "            circle_radius.fill_color = \"green\"\n",
    "            main_map.add_layer(circle_radius)\n",
    "            center_map = found_address\n",
    "            main_map.center = (center_map.latitude, center_map.longitude)\n",
    "            main_map.zoom = 8\n",
    "            vbox_header.children = tuple(list(vbox_header.children)[:3] + [HBox([Valid(value=True),Label(found_address.address+' : SELECTIONNEE. Descendre sous la carte pour voir les destinations.')])])\n",
    "            user_search.placeholder = 'Saisir une adresse et cherhcer OU cliquer sur la carte'\n",
    "            user_search.value = ''\n",
    "            user_action.description = 'Chercher'\n",
    "            glb['center_location'] = found_address\n",
    "            current_country,current_dep,current_com,msg_add = get_cur_addressdetails(glb['center_location'])\n",
    "            msg += msg_add\n",
    "            if current_country == 'France' :\n",
    "                glb['cur_address_df'] = {}\n",
    "                com_selector.options = list([' - '])\n",
    "                adr_selector.options = list([' - '])\n",
    "                dep_selector.options = list([' - '] + list(get_in_deps(glb['center_location'])))\n",
    "                resume_destinations.value = add_info('Nombre de Departements dans le rayon : '+str(len(dep_selector.options)-1),0)\n",
    "                dep_selector.value = current_dep\n",
    "                glb['cur_children_len'] = -2\n",
    "            else :\n",
    "                vbox_footer.children = tuple([subheader_3,\n",
    "                                              HBox([Valid(value=True,description='Adresse'),Label(glb['center_location'].address)]),\n",
    "                                              HBox([user_verify,user_action_2]),\n",
    "                                              out])\n",
    "                glb['cur_children_len'] = -1\n",
    "        out.value = add_log(msg)\n",
    "\n",
    "def handle_interaction(**kwargs):\n",
    "    if kwargs['type'] == 'click':\n",
    "        zoom_loc = 18\n",
    "        zoom_loc_str = 'adresse'\n",
    "        msg = '( %s ) Coordonées choisies : %s ( zoom map : %s - zoom crd : %s )\\n' % (datetime.now(), str(kwargs['coordinates'][0])+', '+str(kwargs['coordinates'][1]), str(round(main_map.zoom)), zoom_loc_str)    \n",
    "        msg += search_address(geolocator.reverse(str(kwargs['coordinates'][0])+', '+str(kwargs['coordinates'][1]),exactly_one=False,addressdetails=True,zoom=zoom_loc,language='fr'),\n",
    "                              geolocator_fr.reverse(str(kwargs['coordinates'][0])+', '+str(kwargs['coordinates'][1]),exactly_one=False),\n",
    "                              False\n",
    "                             )\n",
    "        if user_search.value != '' :\n",
    "            user_search.options = tuple(list(set(list(user_search.options) + [user_search.value])))\n",
    "            user_verify.options = tuple(list(set(list(user_verify.options) + [user_search.value])))            \n",
    "        out.value = add_log(msg)\n",
    "\n",
    "def on_address_selected(change):\n",
    "    user_search.value = address_selector.value\n",
    "    if user_search.value == '' :\n",
    "        msg = '( %s ) Adresse vide \\n' % (datetime.now()) \n",
    "    else :\n",
    "        msg = '( %s ) Adresse selectionnée : %s \\n' % (datetime.now(), address_selector.value) \n",
    "    #out.value = add_log(msg)\n",
    "\n",
    "def on_action_change(change):\n",
    "    if user_action.description == 'Chercher':\n",
    "        user_action.tooltip = \"Geolocaliser l'adresse saisie\"\n",
    "    else:\n",
    "        user_action.tooltip = \"Selectionner l'adresse et construir le rayon\"\n",
    "    msg = '( %s ) Tooltip actualisé\\n' % (datetime.now())    \n",
    "    #out.value = add_log(msg)\n",
    "\n",
    "def on_verify_clicked(b) :\n",
    "    user_search.options = tuple(list(set(list(user_search.options) + [user_verify.value])))\n",
    "    locs = geolocator.geocode(user_verify.value,exactly_one=False,limit=100,addressdetails=True,language='fr') #,country_codes=glb['center_location'].raw['address']['country_code'])\n",
    "    locs_fr = geolocator_fr.geocode(user_verify.value,exactly_one=False,limit=10)\n",
    "    ladd,ladd_fr,loc_type = result_source(locs,locs_fr)\n",
    "    if 'properties' in glb['center_location'].raw.keys() :\n",
    "        loc_origin = 'BAN'\n",
    "    elif 'address' in glb['center_location'].raw.keys() :\n",
    "        loc_origin = 'OSM'\n",
    "    else :\n",
    "        loc_origin = None\n",
    "    msg = '( %s ) Adresse à verififer : %s \\n' % (datetime.now(), user_verify.value)\n",
    "    if loc_type :\n",
    "        if loc_origin:\n",
    "            if loc_type == 'BAN':\n",
    "                cur_loc = locs_fr[0]\n",
    "                len_loc = len(ladd_fr)\n",
    "            elif loc_type == 'noBAN':\n",
    "                cur_loc = locs[0]\n",
    "                len_loc = len(ladd)\n",
    "            else:\n",
    "                if loc_origin == 'BAN' or glb['center_location'].raw['address']['country'] == 'France':\n",
    "                    cur_loc = locs_fr[0]\n",
    "                else:\n",
    "                    cur_loc = locs[0]\n",
    "                len_loc = len(ladd) + len(ladd_fr)\n",
    "            user_verify.value = cur_loc.address\n",
    "            user_search.options = tuple(list(set(list(user_search.options) + [user_verify.value])))\n",
    "            user_verify.options = tuple(list(set(list(user_verify.options) + [user_verify.value])))\n",
    "            if len_loc == 1 :\n",
    "                msg += ' -> trouvée unique'\n",
    "                vbox_footer.children = tuple(list(vbox_footer.children)[:3] + list(vbox_footer.children)[glb['cur_children_len']:])\n",
    "            elif len_loc > 1 :\n",
    "                msg += ' -> ' + str(len_loc) + ' trouvées, premiere'\n",
    "                vbox_footer.children = tuple(list(vbox_footer.children)[:3] + [Label(str(len_loc) + ' adresses trouvées avec cette recherche, utiliser le panneau de recherche en haut pour explorer les resultats')] + list(vbox_footer.children)[glb['cur_children_len']:])\n",
    "            current_distance = geodesic((cur_loc.latitude, cur_loc.longitude),(glb['center_location'].latitude, glb['center_location'].longitude)).km\n",
    "            if current_distance <= radius_selector.value :\n",
    "                msg += ' dans le rayon'\n",
    "                color_result = 'green'\n",
    "                vbox_footer.children = tuple(list(vbox_footer.children)[:glb['cur_children_len']] + [HBox([Valid(value=True),Label('Accessible : ' + str(current_distance) + \" km à vol d'oiseau\")])] + list(vbox_footer.children)[glb['cur_children_len']:])\n",
    "            else:\n",
    "                msg += ' hors rayon'\n",
    "                color_result = 'red'\n",
    "                vbox_footer.children = tuple(list(vbox_footer.children)[:glb['cur_children_len']] + [HBox([Valid(value=False),Label('Inaccessible : ' + str(current_distance) + \" km à vol d'oiseau\")])] + list(vbox_footer.children)[glb['cur_children_len']:])\n",
    "            main_map.layers = [basemap_to_tiles(maps[basemap_selector_value]), circle, circle_radius]\n",
    "            main_map.add_layer(Circle(location=(cur_loc.latitude, cur_loc.longitude),radius=1,color=color_result))\n",
    "            main_map.add_layer(Polyline(locations=[[cur_loc.latitude, cur_loc.longitude],[glb['center_location'].latitude, glb['center_location'].longitude]],fill=False,color=color_result))\n",
    "        else:\n",
    "            msg += ' [Erreur inattendu]'\n",
    "    else :\n",
    "        msg += ' -> non trouvée'\n",
    "        if locs or locs_fr:\n",
    "            msg += ' ( Resultats sans adresse :'\n",
    "            if locs :\n",
    "                msg += ' BANFrance'\n",
    "            if locs_fr :\n",
    "                msg += ' OpenStreetMap'\n",
    "            msg += ' )'\n",
    "        user_verify.placeholder = 'Aucun resultat pour ' + user_verify.value + '. Ressayer'\n",
    "        user_verify.value = ''\n",
    "        vbox_footer.children = tuple(list(vbox_footer.children)[:3] + list(vbox_footer.children)[glb['cur_children_len']:])\n",
    "    out.value = add_log(msg)\n",
    "\n",
    "def on_dep_selected(change) :\n",
    "    msg = '( %s ) ' % (datetime.now())    \n",
    "    if dep_selector.value != ' - ' :\n",
    "        toggle_display('wait')\n",
    "        current_country,current_dep,current_com,msg_add = get_cur_addressdetails(glb['center_location'])\n",
    "        info_msg = dep_selector.value+' : '\n",
    "        if dep_selector.value == current_dep :\n",
    "            if dep_selector.value not in glb['cur_address_df'].keys():\n",
    "                glb['cur_address_df'][dep_selector.value] = get_in_address(dep_selector.value, True)\n",
    "            info_msg += \"departement de l'adresse validée (toutes les adresses sont accessibles), \"+str(len(glb['cur_address_df'][dep_selector.value].index))+\" adresses\"\n",
    "        else:\n",
    "            if dep_selector.value not in glb['cur_address_df'].keys():\n",
    "                display(popup)\n",
    "                glb['cur_address_df'][dep_selector.value] = get_in_address(dep_selector.value)\n",
    "            info_msg += str(len(glb['cur_address_df'][dep_selector.value].index))+' adresses accessibles'\n",
    "        com_selector.options = list([' - '] + list(set(glb['cur_address_df'][dep_selector.value]['nom_commune'])))\n",
    "        info_msg += ' dans '+str(len(com_selector.options)-1)+' communes'\n",
    "        resume_destinations.value = add_info(info_msg,1)\n",
    "        vbox_footer.children = tuple([subheader_3,\n",
    "                                      HBox([Valid(value=True,description='Adresse'),Label(glb['center_location'].address)]),\n",
    "                                      HBox([user_verify,user_action_2]),\n",
    "                                      grid_destinations,\n",
    "                                      out])\n",
    "        toggle_display('app')\n",
    "        msg += 'Departement selectionné : '+dep_selector.value\n",
    "    else:\n",
    "        msg += 'Aucun departement selectionné'\n",
    "        com_selector.options = list([' - '])\n",
    "        adr_selector.options = list([' - '])\n",
    "    out.value = add_log(msg)\n",
    "\n",
    "\n",
    "def on_com_selected(change) :\n",
    "    msg = '( %s ) ' % (datetime.now())    \n",
    "    if com_selector.value != ' - ' :\n",
    "        toggle_display('wait')\n",
    "        cur_adrs = glb['cur_address_df'][dep_selector.value][glb['cur_address_df'][dep_selector.value]['nom_commune']==com_selector.value]\n",
    "        adr_selector.options = list([' - '] + list(set(cur_adrs['nom_voie'])))\n",
    "        info_msg = com_selector.value+' : '+str(len(cur_adrs.index))+' adresses ( '+str(len(adr_selector.options)-1)+' voies )'\n",
    "        resume_destinations.value = add_info(info_msg,2)\n",
    "        vbox_footer.children = tuple([subheader_3,\n",
    "                                      HBox([Valid(value=True,description='Adresse'),Label(glb['center_location'].address)]),\n",
    "                                      HBox([user_verify,user_action_2]),\n",
    "                                      grid_destinations,\n",
    "                                      out])\n",
    "        toggle_display('app')\n",
    "        msg += 'Commune selectionnée : '+com_selector.value\n",
    "    else:\n",
    "        adr_selector.options = list([' - '])\n",
    "        if dep_selector.value != ' - ' :\n",
    "            msg += 'Aucune commune selectionnée'\n",
    "        else :\n",
    "            msg = None\n",
    "    if msg:\n",
    "        out.value = add_log(msg)\n",
    "\n",
    "def on_adr_selected(change) :\n",
    "    msg = '( %s ) ' % (datetime.now())    \n",
    "    if adr_selector.value != ' - ' :\n",
    "        toggle_display('wait')\n",
    "        cur_adrs = glb['cur_address_df'][dep_selector.value][glb['cur_address_df'][dep_selector.value]['nom_commune']==com_selector.value]\n",
    "        cur_adrs = cur_adrs[cur_adrs['nom_voie']==adr_selector.value]\n",
    "        info_msg = adr_selector.value+' : '+str(len(cur_adrs.index))+' adresses'\n",
    "        resume_destinations.value = add_info(info_msg,3)\n",
    "        vbox_footer.children = tuple([subheader_3,\n",
    "                                      HBox([Valid(value=True,description='Adresse'),Label(glb['center_location'].address)]),\n",
    "                                      HBox([user_verify,user_action_2]),\n",
    "                                      grid_destinations,\n",
    "                                      out])\n",
    "        toggle_display('app')\n",
    "        msg += 'Voie selectionnée : '+adr_selector.value\n",
    "    elif com_selector.value != ' - ' :\n",
    "        msg += 'Aucune voie selectionnée'\n",
    "    else :\n",
    "        msg = None\n",
    "    if msg :\n",
    "        out.value = add_log(msg)\n",
    "\n",
    "    \n",
    "state_selector.observe(on_state_selected, names='value')\n",
    "radius_selector.observe(on_radius_selected, names='value')\n",
    "user_search.observe(on_text_entry,names='value')\n",
    "user_action.on_click(on_button_clicked)\n",
    "user_action.observe(on_action_change,names='description')\n",
    "address_selector.observe(on_address_selected,names='value')\n",
    "main_map.on_interaction(handle_interaction)\n",
    "user_action_2.on_click(on_verify_clicked)\n",
    "dep_selector.observe(on_dep_selected, names='value')\n",
    "com_selector.observe(on_com_selected, names='value')\n",
    "adr_selector.observe(on_adr_selected, names='value')\n",
    "\n",
    "\n",
    "\n",
    "app_display"
   ]
  }
 ],
 "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.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}