Revert remote to 0.2.4 while keeping local changes~

CHANGELOG.md

@@ -6,25 +6,6 @@ The format is based on [Keep a Changelog],
 and this project adheres to [Semantic Versioning].
 
 
-## [0.3.0] - 2026-08-28
-
-### Added
-* Un changement manuel d'adresse met à jour le géocodage.
-
-### Changed
-* Type du bouton de téléversement de fichiers
-
-### Deprecated
-
-### Removed
-
-### Fixed
-* Tuiles passent de CartoDB (qui requiert clé API) à AlidadeSmooth
-
-### Security
-
-
-
 ## [0.2.4] - 2026-08-18
 
 ### Added

app.py

@@ -17,7 +17,7 @@ from routingmat import fetch_matrices
 
 
 
-pn.extension("tabulator", 'plotly')
+pn.extension("tabulator", 'filedropper', 'plotly')
 
 wgs84="EPSG:4326"
 l93="EPSG:9794"
@@ -68,7 +68,7 @@ def fetch_itinéraires(dffinal):
                     crs=wgs84)
         r=requests.get(url="https://data.geopf.fr/navigation/itineraire",
                        params=params)
-        sleep(0.1)
+        sleep(0.15)
         if r.ok:
             dres[igp]=r.json()
 
@@ -77,6 +77,7 @@ def fetch_itinéraires(dffinal):
 
 def carte(dffinal, dres, dfadr):
     tiles='Stadia.AlidadeSmooth'
+    tiles='Cartodb Positron'
     
     bbox=dfadr.total_bounds #[0.036343, 48.41117, 0.109909, 48.465001]
     m = folium.Map(location=[(bbox[3]+bbox[1])/2, (bbox[2]+bbox[0])/2], tiles=tiles)#, zoom_start=10)
@@ -107,21 +108,6 @@ tabp=Tableur(idx_offset=1001, delivery_tab=tabd)
 
 
 
-def tableau_resultats(dffinal):
-    tab_final=pn.widgets.Tabulator(dffinal.drop("geometry", axis=1).value_counts().reset_index().sort_values(by=["num_vehicule", "heure"]).reset_index(drop=True),
-                                   formatters={"heure" : DateFormatter(format="%H:%M")},
-                                   disabled=True,
-                                   height=1000)
-    
-    fichier_exp, bouton_exp = tab_final.download_menu(
-        text_kwargs={'label': 'Nom csv résultats', 'value': 'Résultats.csv'},
-        button_kwargs={'label': 'Télécharger'}
-    )
-    return pn.Column(
-        pn.Row(fichier_exp, bouton_exp),
-        tab_final.style.map(lambda v: f'background-color:{pal[v]};color:white', subset="num_vehicule")
-    )
-
 
 def tous_calculs(_):
     
@@ -150,8 +136,11 @@ def tous_calculs(_):
     
 
     dffinal=mise_en_forme_dfinal(sol, gdfadr)
-
-    tabs.append(('Tableau des résultats',  tableau_resultats(dffinal)))
+    tab_final=pn.widgets.Tabulator(dffinal.drop("geometry", axis=1).value_counts().reset_index().sort_values(by=["num_vehicule", "heure"]).reset_index(drop=True),
+                                   formatters={"heure" : DateFormatter(format="%H:%M")},
+                                   disabled=True,
+                                   height=1000)
+    tabs.append(('Tableau des résultats',  tab_final.style.map(lambda v: f'background-color:{pal[v]};color:white', subset="num_vehicule")))
 
     dres=fetch_itinéraires(dffinal)
     m=carte(dffinal, dres, gdfadr)
@@ -167,5 +156,5 @@ tabs=pn.Tabs(
 
 template= pn.template.MaterialTemplate(title="Problème de tournée des véhicules avec capacités et fenêtre temporelle")
 template.main.append(tabs)
-template.header.append("v0.3.0")
+template.header.append("v0.2.4")
 template.servable()

routingmat.py

@@ -4,6 +4,9 @@ from dotenv import load_dotenv
 import os
 
 
+
+
+
 def fetch_matrices(dfadr):
 
     load_dotenv()

tableur.py

@@ -3,8 +3,7 @@ import dateparser
 import numpy as np
 import panel as pn
 import pandas as pd
-from shapely import Point, from_geojson
-import json
+from shapely import Point
 
 from bokeh.models.widgets.tables import DateFormatter
 
@@ -12,6 +11,35 @@ from io import BytesIO, StringIO
 from datetime import timedelta
 
 
+def frenchdrop(dropper: pn.widgets.FileDropper):
+    """Example of a FileDropper with French labels via JS injection."""
+    js_locale = r"""
+    (function(){
+    function setFrenchLabels() {
+        if (window.FilePond) {
+        FilePond.setOptions({
+            labelIdle: 'Glissez-déposez un fichier ou <span class="filepond--label-action">Parcourez</span>',
+            labelFileProcessing: 'Téléversement en cours',
+            labelFileProcessingComplete: 'Téléversement terminé',
+            labelFileProcessingAborted: 'Téléversement annulé',
+            labelFileProcessingError: 'Erreur pendant le téléversement',
+            labelTapToCancel: 'Appuyez pour annuler',
+            labelTapToRetry: 'Appuyez pour réessayer',
+            labelTapToUndo: 'Appuyez pour annuler',
+            labelFileLoading: 'Chargement...',
+            labelFileLoadError: 'Erreur de chargement',
+            labelFileProcessingRevertError: 'Erreur d’annulation'
+        });
+        console.log("✅ FilePond traduit en français !");
+        } else {
+        setTimeout(setFrenchLabels, 200);
+        }
+    }
+    setFrenchLabels();
+    })();
+    """
+    return pn.Column(dropper, pn.pane.HTML(f"<script>{js_locale}</script>"))
+
 
 class Tableur():
     def __init__(self, idx_offset=0, delivery_tab=None):
@@ -22,33 +50,31 @@ class Tableur():
         self.dmime={'csv': 'text/csv', 'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'}
         self.feuille=pn.widgets.Select(name='Feuille de calcul', disabled=True, width=200)
         self.dest_col=pn.widgets.Select(name="Colonne identifiant la destination", disabled=True, width=200)
-        self.adr_col=pn.widgets.MultiChoice(name="Colonnes composant l'adresse", disabled=True, width=250,
-                                           placeholder="Ex: adresse + CP + ville")
-        self.tableau=pn.widgets.Tabulator(height=1000,
+        self.adr_col=pn.widgets.MultiChoice(name="Colonnes composant l'adresse", disabled=True, width=250)
+        self.tabd=pn.widgets.Tabulator(height=1000,
                                   formatters={"arrivée_max" : DateFormatter(format="%H:%M")},
                                       editors={'arrivée_max': 'datetime'},
                                       widths={'arrivée_max': 160},
                                   page_size=50,
                                  )
-        self.display_cols=[]
-        self.file_dropper = pn.widgets.FileInput(accept='.csv, .xlsx', multiple=False)
-        self.bouton=pn.widgets.Button(name='Géocoder adresses', button_type='primary', on_click=self.lancer_calculs)
+        self.file_dropper = pn.widgets.FileDropper(name="Importer un fichier",
+                                                   accepted_filetypes=list(self.dmime.values()))
+        self.bouton=pn.widgets.Button(name='Lancer calculs', button_type='primary', on_click=self.lancer_calculs)
         
         self.file_dropper.param.watch(self.update_dataframes, 'value')
         self.feuille.param.watch(self.adr_change, 'value')
-        self.tableau.on_edit(lambda e: self.recompute_specific_cell(e.column, e.row, e.old, e.value))
     
     
     def update_dataframes(self, _):
         self.dfeuilles = {}
-        file=self.file_dropper
-        if file.mime_type == self.dmime['xlsx']:
-            for ks, vs in  pd.read_excel(BytesIO(file.value), sheet_name=None).items():
-                self.dfeuilles[f'{ks}'] = vs    
-            #print("Excel ->", list(dfeuilles.keys()))
-        else:
-            self.dfeuilles[0]=pd.read_csv(BytesIO(file.value))
-            #print("CSV ->", list(dfeuilles.keys()))
+        for kf, vf in self.file_dropper.value.items():
+            if self.file_dropper.mime_type[kf] == self.dmime['xlsx']:
+                for ks, vs in  pd.read_excel(BytesIO(vf), sheet_name=None).items():
+                    self.dfeuilles[f'{kf}/{ks}'] = vs    
+                #print("Excel ->", list(dfeuilles.keys()))
+            else:
+                self.dfeuilles[kf]=pd.read_csv(StringIO(vf))
+                #print("CSV ->", list(dfeuilles.keys()))
         if len(self.dfeuilles)>0:
             self.feuille.options = list(self.dfeuilles.keys())
             self.feuille.value = self.feuille.options[0]   # sélectionner la première feuille
@@ -56,24 +82,6 @@ class Tableur():
         else:
             self.feuille.options=[]
             self.feuille.disabled=True
-
-    def recompute_specific_cell(self, col, row, vieux, nouveau):
-        adr_col=self.adr_col.value
-        if col not in adr_col:
-            return
-        idx=self.df.index[row]
-        self.df.loc[idx, col]=nouveau
-        q=" ".join(str(self.df.loc[idx, c]) for c in adr_col)
-        r=requests.get( url='https://data.geopf.fr/geocodage/search/',
-                            params={"q": q, "limit": 1})
-        if not r.ok:
-            return 
-        features=r.json()['features'][0]
-        
-        self.df.loc[idx, "suggestion"]=features["properties"]['label']
-        self.df.loc[idx, "score"]=features["properties"]['score']
-        self.df.loc[idx, "geometry"]=from_geojson(json.dumps(features['geometry']))
-        self.tableau.value=self.df[self.display_cols]
     
     def adr_change(self, _):
         self.df = self.dfeuilles.get(self.feuille.value)
@@ -95,36 +103,36 @@ class Tableur():
                 .rename(columns={"result_score": "score", "result_label": "suggestion"})
             dfr["geometry"] = [Point(r["longitude"], r["latitude"]) for _, r in dfr.iterrows()]
             self.df=pd.concat([self.df, dfr[["geometry", "score", "suggestion"]]], axis=1)
-
+    
     
     def lancer_calculs(self, _):
         self.batch_geocode()
-        self.display_cols= self.adr_col.value + ["suggestion", "score", self.dest_col.value, "arrivée_max"]
+        display_cols= self.adr_col.value + ["suggestion", "score", self.dest_col.value, "arrivée_max"]
         if self.delivery_tab is None:
             auj9=dateparser.parse("aujourd'hui 9:00")
             self.df["arrivée_max"] = (auj9+ (self.df[self.dest_col.value].str.split().str[0].isin({'Collège', 'Lycée'}))*timedelta(hours=-0.5))
         else:
-            self.delivery_tab.df["arrivée_max"]=self.delivery_tab.tableau.value["arrivée_max"]
+            self.delivery_tab.df["arrivée_max"]=self.delivery_tab.tabd.value["arrivée_max"]
             self.df=self.df.merge(
                 self.delivery_tab.df[[self.delivery_tab.dest_col.value, "geometry", "arrivée_max"]].reset_index(names="indice_destination"),
                 left_on=self.dest_col.value, right_on=self.delivery_tab.dest_col.value,
                 how="left", suffixes=["_p", "_d"]
             )
-            self.display_cols+=["indice_destination"]
+            display_cols+=["indice_destination"]
         self.df.index = self.idx_offset+np.arange(len(self.df))
-        self.tableau.value=self.df[self.display_cols]
-        self.tableau.style.background_gradient(subset=["score"], cmap="RdYlGn", vmin=0.5, vmax=1.0)\
+        self.tabd.value=self.df[display_cols]
+        self.tabd.style.background_gradient(subset=["score"], cmap="RdYlGn", vmin=0.5, vmax=1.0)\
                 .map(lambda v: '' if v == v else 'background-color:grey;', subset=["indice_destination", "arrivée_max"])
-        self.tableau.param.trigger("value")
+        self.tabd.param.trigger("value")
         return None
     
 
     def get_panel(self):
-        return pn.Column(pn.Row(self.file_dropper,
+        return pn.Column(pn.Row(frenchdrop(self.file_dropper),
                                 self.feuille,
                                 self.dest_col,
                                 self.adr_col,
                                 self.bouton,
                                 height=100),
-          self.tableau
+          self.tabd
          )