🥾🎒 Liste des traces GPX issus d'un GPS (python desktop tableauqt.py)

Dossier travail: $HOME/media/dplus/cartographie/analyse-gpx/

Prérequis: uv (Archlinux, yay -S uv)

Tableau

Description

Le script tableauqt.py lance une petite application Qt qui charge un fichier JSON contenant des traces GPX, puis affiche ces données dans une table avec :

• recherche (filtre texte sur toutes les colonnes)
• tri par colonne (avec tri spécial sur jour en date)
• affichage/masquage de colonnes “cachables” (id/latitude/longitude et gpx)
• thème clair/sombre
• copie des GPX sélectionnés vers un dossier temporaire
• sauvegarde des préférences d’UI (colonnes visibles, tri, thème) dans un fichier de config JSON.
• Drag n drop

Fonctionnement concret

1. Au démarrage, il lit un fichier config.json (ou celui passé via --config) et en extrait :
   • json_path (le JSON à afficher),
   • gpx_dir (dossier contenant les .gpx),
   • éventuellement temp_dir, visible_columns, default_sort, window, theme.
2. Il charge tracestableau.json en mémoire (self.data) puis affiche toutes les lignes.
3. Chaque ligne correspond à un élément avec les colonnes : id, latitude, longitude, lieu, commune, cp, distance, vitesse, niveau, jour, gpx.
4. La barre “Recherche” filtre la table en gardant les lignes où le texte recherché apparaît dans n’importe quelle colonne.
5. Cliquer sur un en-tête trie la table, et il met une flèche ↓/↑ sur l’en-tête de la colonne active.
6. Les boutons “Toggle id/lat/lon” et “Toggle gpx” masquent/affichent ces colonnes et mettent à jour la vue + la config.
7. “Copier GPX sélection” :
   • récupère gpx pour les lignes sélectionnées,
   • copie les fichiers correspondants depuis GPX_DIR vers TEMP_DIR (avec shutil.copy2),
   • affiche la liste copiée dans la console.
8. Le bouton “Afficher sélection (id)” affiche juste les id des lignes sélectionnées dans la console.
9. geo_cache/géocodage n’est pas concerné ici : il travaille uniquement sur le JSON déjà produit.

Paramètres config.json

Fichier ~/.config/tableau/config.json

{
  "default_sort": {
    "column": "jour",
    "descending": true
  },
  "json_path": "/sharenfs/traces-gpx/tracestableau.json",
  "gpx_dir": "/sharenfs/traces-gpx",
  "temp_dir": "/tmp/gpx-studio-drop",
  "visible_columns": [
    "lieu",
    "commune",
    "cp",
    "distance",
    "vitesse",
    "niveau",
    "jour",
    "gpx"
  ],
  "window": {
    "width": 1200,
    "height": 700,
    "icon_path": "/home/yann/.config/tableau/tableau-gpx.png"
  },
  "theme": {
    "mode": "dark"
  }
}

Script tableauqt.py

Qt utilise le protocole DnD natif (Wayland/XDG ou X11), donc le drag sortant de fichiers GPX vers Dolphin, GPX Studio ou autre fonctionne directement.

~/media/dplus/cartographie/analyse-gpx/tableauqt.py

Ce que fait le port :

• QTableView + QAbstractTableModel : le drag sortant est implémenté via mimeData() du modèle, qui retourne les fichiers GPX des lignes sélectionnées en text/uri-list (le standard que toutes les applications comprennent).
• Tri par clic d’en-tête via QSortFilterProxyModel (avec l’indicateur ▲/▼ intégré), recherche instantanée sur toutes les colonnes, tout comme votre version.
• Les mêmes fonctionnalités : affichage sélection uniquement, toggle des colonnes id/lat/lon/gpx, copie des GPX vers /tmp/gpx-studio-drop, thème clair/sombre (via QSS), icône et dimensions de fenêtre.
• La persistance dans config.json est conservée (colonnes visibles, tri, thème, taille de fenêtre), avec le même format de clés : votre config.json actuel fonctionne tel quel.

Ajout importation et intégration fichier GPX

Choix par rapport à ton script d’import :

• Géocodage dans un thread (QThread) : Nominatim impose environ 1 requête par seconde, l’interface ne se fige donc pas. Une barre de progression avec bouton Annuler s’affiche pendant l’import.
• JSON relu et réécrit proprement (json.dump, écriture atomique) au lieu de la bidouille sur le ] final. Les nouveaux id partent de max(id) + 1.
• Doublons ignorés d’après le nom du fichier GPX, comme dans ton script. Le fichier est copié dans gpx_dir.
• geo_cache.json est stocké à côté de tracestableau.json. Un échec de géocodage n’est pas mis en cache, donc il sera retenté la fois suivante.
• Fichiers sources conservés : ton script les supprimait après import, je ne l’ai pas reproduit par prudence.
• Fichier addressPoints JS : il n’est régénéré que si tu ajoutes "js_path": "..." dans config.json.

Dépendances : pip install gpxpy geopy

uv pip install gpxpy geopy

Le fichier modifié tableauqt.py

#!/usr/bin/env python3
# tableauqt.py - port PySide6 de tableau.py (tkinter -> Qt)
#
# Installation :
#   pip install PySide6
#
# Lancement :
#   python tableauqt.py --config config.json
#
# Le drag & drop sortant (fichiers GPX vers une autre appli) utilise
# QDrag + QMimeData avec des URLs de fichiers : c'est la méthode native
# Qt, bien plus fiable que TkinterDnD2 sous KDE Plasma / Wayland.
import time

import gpxpy
from geopy.geocoders import Nominatim

from PySide6.QtCore import QThread, Signal
from PySide6.QtWidgets import QProgressDialog

import argparse
import json
import shutil
import sys
from datetime import datetime
from pathlib import Path

from PySide6.QtCore import (
    QAbstractTableModel, QMimeData, QModelIndex, QSortFilterProxyModel,
    QUrl, Qt,
)
from PySide6.QtGui import QAction, QDrag, QIcon
from PySide6.QtWidgets import (
    QApplication, QFileDialog, QHBoxLayout, QHeaderView, QLineEdit,
    QMainWindow, QMessageBox, QPushButton, QStatusBar, QTableView,
)

# --- config par défaut (écrasées par le fichier config.json) ---

JSON_PATH = "/home/yann/media/dplus/cartographie/analyse-gpx/traces/tracestableau.json"
GPX_DIR = Path("/home/yann/media/dplus/cartographie/analyse-gpx/traces")
TEMP_DIR = "/tmp/gpx-studio-drop"
JS_PATH = None  # optionnel : fichier "var addressPoints = [...]"

COLUMNS = ["id", "latitude", "longitude", "lieu", "commune", "cp",
           "distance", "vitesse", "niveau", "jour", "gpx"]

HIDEABLE_COLS = {"id", "latitude", "longitude", "gpx"}
DEFAULT_VISIBLE = {"lieu", "commune", "cp", "distance", "vitesse", "niveau", "jour", "gpx"}

COL_WIDTHS = {"lieu": 220, "gpx": 220, "commune": 170, "jour": 95,
              "id": 90, "latitude": 90, "longitude": 90}


def load_config(path):
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


def save_config(path, cfg):
    with open(path, "w", encoding="utf-8") as f:
        json.dump(cfg, f, ensure_ascii=False, indent=2)


# --- modèle ---


class TraceTableModel(QAbstractTableModel):
    """Modèle plat sur la liste de dicts du JSON."""

    def __init__(self, rows, parent=None):
        super().__init__(parent)
        self.rows = rows

    # Qt API ------------------------------------------------------------

    def rowCount(self, parent=QModelIndex()):
        return 0 if parent.isValid() else len(self.rows)

    def columnCount(self, parent=QModelIndex()):
        return len(COLUMNS)

    def data(self, index, role=Qt.DisplayRole):
        if not index.isValid():
            return None
        row = self.rows[index.row()]
        col = COLUMNS[index.column()]
        if role in (Qt.DisplayRole, Qt.EditRole):
            v = row.get(col, "")
            return "" if v is None else str(v)
        if role == Qt.UserRole:
            return row
        return None

    def headerData(self, section, orientation, role=Qt.DisplayRole):
        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
            return COLUMNS[section]
        return None

    def flags(self, index):
        return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled

    def mimeTypes(self):
        return ["text/uri-list"]

    def mimeData(self, indexes):
        """Drag sortant : les fichiers GPX des lignes sélectionnées."""
        mime = QMimeData()
        urls, seen = [], set()
        for idx in indexes:
            row = self.rows[idx.row()]
            name = row.get("gpx", "")
            if not name:
                continue
            p = GPX_DIR / str(name)
            if p.is_file() and p not in seen:
                seen.add(p)
                urls.append(QUrl.fromLocalFile(str(p)))
        if not urls:
            return None
        mime.setUrls(urls)
        return mime

    # helpers ------------------------------------------------------------

    def row_at(self, proxy_index, proxy_model):
        src_index = proxy_model.mapToSource(proxy_index)
        return self.rows[src_index.row()]


# --- import GPX ---


def _fmt(v, nd=2):
    return f"{v:.{nd}f}"


def _to_float(v):
    try:
        return float(v)
    except (TypeError, ValueError):
        return None


def _write_json_atomic(path, rows):
    tmp = Path(str(path) + ".tmp")
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump(rows, f, ensure_ascii=False, indent=1)
        f.write("\n")
    tmp.replace(path)


def _write_js(path, rows):
    with open(path, "w", encoding="utf-8") as f:
        f.write("var addressPoints = [\n")
        for r in rows:
            arr = [_to_float(r.get("latitude")), _to_float(r.get("longitude")),
                   r.get("lieu", ""), r.get("commune", ""), r.get("cp", ""),
                   r.get("distance", ""), r.get("vitesse", ""),
                   r.get("niveau", ""), r.get("jour", ""), r.get("gpx", ""),
                   _to_int(r.get("id"))]
            f.write(json.dumps(arr, ensure_ascii=False) + ",\n")
        f.write("];\n")


def _log(msg):
    print(f"[import] {msg}", file=sys.stderr, flush=True)


class ImportWorker(QThread):
    """Parse les GPX + géocodage inverse (lent) hors du thread GUI."""

    progress = Signal(int, str)       # index, nom du fichier en cours
    step = Signal(int)                # nombre de fichiers terminés
    done = Signal(list, list, list)   # [(entry, Path)], erreurs, ignorés

    def __init__(self, files, existing_names, start_id, cache_path, parent=None):
        super().__init__(parent)
        self.files = [Path(f) for f in files]
        self.existing = set(existing_names)
        self.start_id = start_id
        self.cache_path = Path(cache_path)

    def run(self):
        try:
            self._run()
        except Exception:
            import traceback
            traceback.print_exc()
            self.done.emit([], ["erreur interne du worker (voir le terminal)"], [])

    def _run(self):
        _log(f"démarrage : {len(self.files)} fichier(s)")
        cache = {}
        if self.cache_path.exists():
            try:
                cache = json.loads(self.cache_path.read_text(encoding="utf-8"))
            except Exception:
                cache = {}

        self.geolocator = Nominatim(user_agent="tableauqt-gpx-import", timeout=10)
        entries, errors, skipped = [], [], []
        next_id = self.start_id

        for i, path in enumerate(self.files):
            if self.isInterruptionRequested():
                break
            name = path.name
            self.progress.emit(i, name)
            _log(f"{i + 1}/{len(self.files)} : {name}")
            if name in self.existing:
                skipped.append(name)
                self.step.emit(i + 1)
                continue
            try:
                entry = self._build_entry(path, next_id, cache)
            except Exception as e:
                _log(f"  erreur : {e!r}")
                errors.append(f"{name} : {e}")
                self.step.emit(i + 1)
                continue
            entries.append((entry, path))
            self.existing.add(name)
            next_id += 1
            self.step.emit(i + 1)

        try:
            self.cache_path.write_text(
                json.dumps(cache, ensure_ascii=False, indent=2), encoding="utf-8")
        except Exception:
            pass
        self.done.emit(entries, errors, skipped)

    # ------------------------------------------------------------------

    def _reverse(self, lat, lon, cache):
        key = f"{round(lat, 6)},{round(lon, 6)}"
        if cache.get(key):
            return cache[key]
        last = None
        for attempt in range(3):
            if self.isInterruptionRequested():
                raise RuntimeError("annulé")
            try:
                _log(f"  géocodage {key} (essai {attempt + 1})")
                loc = self.geolocator.reverse(f"{lat},{lon}")
                if loc and getattr(loc, "address", None):
                    cache[key] = loc.address
                    time.sleep(1.1)  # politique d'usage Nominatim : 1 req/s
                    return loc.address
                break
            except Exception as e:
                last = e
                _log(f"  échec : {e!r}")
                time.sleep(2)
        raise RuntimeError(f"géocodage impossible ({last or 'aucune adresse'})")

    def _build_entry(self, path, new_id, cache):
        with open(path, "r", encoding="utf-8") as f:
            gpx = gpxpy.parse(f)

        points = []
        for trk in gpx.tracks:
            for seg in trk.segments:
                points.extend(seg.points)
        _log(f"  gpx parsé : {len(points)} points")
        if not points:
            raise ValueError("aucun point de trace")
        lat, lon = points[0].latitude, points[0].longitude

        parts = [p.strip() for p in self._reverse(lat, lon, cache).split(",")]
        z = len(parts)

        def part(idx):
            return parts[idx] if 0 <= idx < z else ""

        try:
            length_2d = gpx.length_2d() or 0.0
        except Exception:
            length_2d = 0.0
        try:
            md = gpx.get_moving_data()
            moving_time, moving_distance = md.moving_time, md.moving_distance
        except Exception:
            moving_time = moving_distance = 0.0
        try:
            uphill, _down = gpx.get_uphill_downhill()
        except Exception:
            uphill = 0.0
        try:
            start_time, _end = gpx.get_time_bounds()
        except Exception:
            start_time = None

        vmoy = (moving_distance / moving_time) * 3.6 if moving_time else 0.0

        return {
            "id": new_id,
            "latitude": lat,
            "longitude": lon,
            "lieu": part(z - 8),
            "commune": part(z - 7),
            "cp": part(z - 2),
            "distance": _fmt(length_2d / 1000.0, 3),
            "vitesse": _fmt(vmoy),
            "niveau": _fmt(uphill or 0.0),
            "jour": start_time.strftime("%Y-%m-%d") if start_time else "n/a",
            "gpx": path.name,
        }


# --- fenêtre principale ---

class MainWindow(QMainWindow):
    def __init__(self, json_path, visible_columns, default_sort,
                 config_path=None, window_cfg=None, theme_cfg=None):
        super().__init__()
        self.config_path = config_path
        self.window_cfg = window_cfg or {}
        self.theme_mode = (theme_cfg or {}).get("mode", "light")
        self.show_only_selection = False
        self.selected_ids = set()
        self.sort_col = default_sort["column"]
        self.sort_desc = bool(default_sort.get("descending", True))
        self.visible_cols = set(visible_columns)

        with open(json_path, "r", encoding="utf-8") as f:
            self.data = json.load(f)
        self.filtered = list(self.data)

        self.model = TraceTableModel(self.filtered)
        self.proxy = QSortFilterProxyModel(self)
        self.proxy.setSourceModel(self.model)
        self.proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.proxy.setFilterKeyColumn(-1)  # toutes les colonnes

        self.setWindowTitle("Table JSON - tri + recherche (Qt)")
        w = int(self.window_cfg.get("width", 1200))
        h = int(self.window_cfg.get("height", 700))
        self.resize(w, h)
        self._apply_window_icon()

        # --- UI ---
        top = self._top_bar()
        self.table = QTableView()
        self.table.setModel(self.proxy)
        self.table.setSelectionMode(QTableView.ExtendedSelection)
        self.table.setSelectionBehavior(QTableView.SelectRows)
        self.table.setDragEnabled(True)
        self.table.setDragDropMode(QTableView.DragOnly)
        self.table.setSortingEnabled(True)
        self.table.verticalHeader().setVisible(False)
        self.table.setAlternatingRowColors(True)
        self.table.setShowGrid(False)

        header = self.table.horizontalHeader()
        header.setSectionResizeMode(QHeaderView.Interactive)
        header.sortIndicatorChanged.connect(self._on_sort_changed)
        self._apply_column_layout()

        bottom = self._bottom_bar()

        central = self._central_widget(top, self.table, bottom)
        self.setCentralWidget(central)
        self.setStatusBar(QStatusBar())

        # tri initial
        col = COLUMNS.index(self.sort_col) if self.sort_col in COLUMNS else 0
        self.table.sortByColumn(
            col, Qt.DescendingOrder if self.sort_desc else Qt.AscendingOrder)

        self.apply_theme()

    # --- construction UI ---

    def _central_widget(self, top, table, bottom):
        from PySide6.QtWidgets import QWidget, QVBoxLayout
        w = QWidget()
        lay = QVBoxLayout(w)
        lay.setContentsMargins(10, 8, 10, 8)
        lay.addWidget(top)
        lay.addWidget(table, 1)
        lay.addWidget(bottom)
        return w

    def _top_bar(self):
        from PySide6.QtWidgets import QWidget, QLabel
        w = QWidget()
        lay = QHBoxLayout(w)
        lay.setContentsMargins(0, 0, 0, 0)
        lay.addWidget(QLabel("Recherche :"))
        self.search_edit = QLineEdit()
        self.search_edit.setClearButtonEnabled(True)
        self.search_edit.textChanged.connect(self.apply_filter)
        lay.addWidget(self.search_edit, 1)
        return w

    def _bottom_bar(self):
        from PySide6.QtWidgets import QWidget
        w = QWidget()
        lay = QHBoxLayout(w)
        lay.setContentsMargins(0, 0, 0, 0)

        self.btn_selection = QPushButton("Afficher sélection (id)")
        self.btn_selection.clicked.connect(self.toggle_selection_view)
        lay.addWidget(self.btn_selection)

        self.btn_theme = QPushButton("Thème: clair/sombre")
        self.btn_theme.clicked.connect(self.toggle_theme)
        lay.addWidget(self.btn_theme)

        btn_idlatlon = QPushButton("Toggle id/lat/lon")
        btn_idlatlon.clicked.connect(
            lambda: self.toggle_hidden(["id", "latitude", "longitude"]))
        lay.addWidget(btn_idlatlon)

        btn_gpx = QPushButton("Toggle gpx")
        btn_gpx.clicked.connect(lambda: self.toggle_hidden(["gpx"]))
        lay.addWidget(btn_gpx)

        btn_copy = QPushButton("Copier GPX sélection")
        btn_copy.clicked.connect(self.copy_selected_gpx_to_temp)
        lay.addWidget(btn_copy)

        self.btn_import = QPushButton("Importation")
        self.btn_import.clicked.connect(self.import_gpx)
        lay.addWidget(self.btn_import)

        lay.addStretch(1)
        return w

    def _apply_window_icon(self):
        icon_file = self.window_cfg.get("icon_path")
        if not icon_file:
            return
        p = Path(icon_file).expanduser().resolve()
        if p.exists():
            self.setWindowIcon(QIcon(str(p)))

    # --- colonnes ---

    def _apply_column_layout(self):
        for i, c in enumerate(COLUMNS):
            if c in HIDEABLE_COLS and c not in self.visible_cols:
                self.table.hideColumn(i)
            else:
                self.table.showColumn(i)
                self.table.setColumnWidth(i, COL_WIDTHS.get(c, 80))

    def toggle_hidden(self, which):
        any_visible = any(c in self.visible_cols for c in which)
        if any_visible:
            self.visible_cols -= set(which)
        else:
            self.visible_cols |= set(which)
        self._apply_column_layout()
        self.save_ui_state()

    # --- tri / filtre ---

    def _on_sort_changed(self, column, order):
        self.sort_col = COLUMNS[column]
        self.sort_desc = (order == Qt.DescendingOrder)
        self.save_ui_state()

    def apply_filter(self):
        q = self.search_edit.text().strip()
        if self.show_only_selection:
            # repasse en vue complète puis réapplique la sélection
            self.toggle_selection_view()
        self.proxy.setFilterFixedString(q)

    # --- sélection ---

    def _selected_ids(self):
        ids = set()
        for idx in self.table.selectionModel().selectedRows(0):
            src = self.proxy.mapToSource(idx)
            row = self.model.rows[src.row()]
            try:
                ids.add(int(row.get("id")))
            except (TypeError, ValueError):
                pass
        return ids

    def toggle_selection_view(self):
        if not self.show_only_selection:
            self.selected_ids = self._selected_ids()
            if not self.selected_ids:
                return
            self.show_only_selection = True
            self.filtered = [r for r in self.data
                             if _to_int(r.get("id")) in self.selected_ids]
            self.btn_selection.setText("Afficher tout")
        else:
            self.show_only_selection = False
            self.filtered = list(self.data)
            self.btn_selection.setText("Afficher sélection (id)")
        # réapplique le filtre de recherche et le tri courants
        self.model.beginResetModel()
        self.model.rows = self.filtered
        self.model.endResetModel()
        self.proxy.setFilterFixedString(self.search_edit.text().strip())

    # --- GPX ---

    def _selected_gpx_names(self):
        names = []
        gpx_col = COLUMNS.index("gpx")
        for idx in self.table.selectionModel().selectedRows():
            src = self.proxy.mapToSource(idx)
            name = self.model.rows[src.row()].get("gpx", "")
            if name:
                names.append(str(name))
        return names

    def copy_selected_gpx_to_temp(self):
        temp_dir = TEMP_DIR
        names = self._selected_gpx_names()
        if not names:
            QMessageBox.information(self, "Copier GPX",
                                    "Aucune ligne sélectionnée (ou colonne gpx vide).")
            return
        Path(temp_dir).mkdir(parents=True, exist_ok=True)
        copied, missing = [], []
        for name in names:
            src = GPX_DIR / name
            if src.is_file():
                shutil.copy2(src, Path(temp_dir) / src.name)
                copied.append(src.name)
            else:
                missing.append(str(src))
        msg = f"{len(copied)} fichier(s) copié(s) dans :\n{temp_dir}"
        if missing:
            msg += "\n\nIntrouvables :\n" + "\n".join(missing)
        QMessageBox.information(self, "Copier GPX", msg)


    # --- importation ---
    def import_gpx(self):
        start_dir = getattr(self, "_last_import_dir", str(Path.home()))
        files, _ = QFileDialog.getOpenFileNames(
            self, "Importer des traces GPX", start_dir,
            "Traces GPX (*.gpx *.GPX)")
        if not files:
            return
        self._last_import_dir = str(Path(files[0]).parent)

        existing = {str(r.get("gpx", "")) for r in self.data}
        ids = [i for i in (_to_int(r.get("id")) for r in self.data) if i is not None]
        start_id = (max(ids) + 1) if ids else 0
        cache_path = Path(JSON_PATH).parent / "geo_cache.json"

        # worker créé AVANT le dialogue : s'il échoue, rien ne reste bloqué
        self._worker = ImportWorker(files, existing, start_id, cache_path, self)

        self.btn_import.setEnabled(False)
        self._dlg = QProgressDialog("Importation…", "Annuler", 0, len(files), self)
        self._dlg.setWindowTitle("Importation GPX")
        self._dlg.setWindowModality(Qt.WindowModal)
        self._dlg.setMinimumDuration(0)
        self._dlg.setAutoClose(False)
        self._dlg.setAutoReset(False)
        self._dlg.setValue(0)

        self._worker.progress.connect(self._on_import_progress)
        self._worker.step.connect(self._dlg.setValue)
        self._worker.done.connect(self._on_import_done)
        self._dlg.canceled.connect(self._worker.requestInterruption)
        self._worker.start()

    def _on_import_progress(self, i, name):
        self._dlg.setLabelText(f"({i + 1}/{self._dlg.maximum()}) {name}")
        self._dlg.setValue(i)

    def _on_import_done(self, entries, errors, skipped):
        self._dlg.canceled.disconnect()
        self._dlg.close()
        self.btn_import.setEnabled(True)

        added = 0
        Path(GPX_DIR).mkdir(parents=True, exist_ok=True)
        for entry, src in entries:
            dest = Path(GPX_DIR) / src.name
            try:
                if not dest.exists() or dest.resolve() != src.resolve():
                    shutil.copy2(src, dest)
            except Exception as e:
                errors.append(f"{src.name} : copie impossible ({e})")
                continue
            self.data.append(entry)
            added += 1

        if added:
            try:
                _write_json_atomic(Path(JSON_PATH), self.data)
                if JS_PATH:
                    _write_js(JS_PATH, self.data)
            except Exception as e:
                errors.append(f"écriture du JSON impossible : {e}")

            # retour à la vue complète et rafraîchissement du modèle
            self.show_only_selection = False
            self.btn_selection.setText("Afficher sélection (id)")
            self.filtered = list(self.data)
            self.model.beginResetModel()
            self.model.rows = self.filtered
            self.model.endResetModel()

        msg = f"{added} trace(s) importée(s)."
        if skipped:
            msg += f"\n{len(skipped)} déjà présente(s), ignorée(s)."
        if errors:
            msg += "\n\nErreurs :\n" + "\n".join(errors)
        self.statusBar().showMessage(f"Importation terminée : {added} ajoutée(s)", 8000)
        QMessageBox.information(self, "Importation", msg)

    # --- thème ---

    def apply_theme(self):
        is_dark = self.theme_mode == "dark"
        app = QApplication.instance()
        if is_dark:
            app.setStyleSheet(DARK_QSS)
        else:
            app.setStyleSheet("")
        self.btn_theme.setText(f"Thème: {'sombre' if is_dark else 'clair'}")

    def toggle_theme(self):
        self.theme_mode = "light" if self.theme_mode == "dark" else "dark"
        self.apply_theme()
        self.save_theme_mode()

    # --- persistance ---

    def save_ui_state(self):
        if not self.config_path:
            return
        cfg = load_config(self.config_path)
        cfg["visible_columns"] = [c for c in COLUMNS if c in self.visible_cols]
        cfg["default_sort"] = {"column": self.sort_col,
                               "descending": bool(self.sort_desc)}
        cfg["window"] = {"width": self.width(), "height": self.height()}
        save_config(self.config_path, cfg)

    def save_theme_mode(self):
        if not self.config_path:
            return
        cfg = load_config(self.config_path)
        cfg["theme"] = cfg.get("theme", {})
        cfg["theme"]["mode"] = self.theme_mode
        save_config(self.config_path, cfg)

    def closeEvent(self, event):
        self.save_ui_state()
        super().closeEvent(event)


def _to_int(v):
    try:
        return int(v)
    except (TypeError, ValueError):
        return None


DARK_QSS = """
QWidget { background-color: #1e1e1e; color: #eaeaea; }
QTableView {
    background-color: #2b2b2b; color: #eaeaea;
    gridline-color: #3c3c3c; alternate-background-color: #303030;
    selection-background-color: #094771; selection-color: #ffffff;
}
QHeaderView::section {
    background-color: #303030; color: #eaeaea;
    border: 1px solid #3c3c3c; padding: 4px;
}
QLineEdit, QPushButton {
    background-color: #2b2b2b; border: 1px solid #3c3c3c;
    border-radius: 4px; padding: 4px 8px;
}
QPushButton:hover { background-color: #3a3a3a; }
QStatusBar { background-color: #1e1e1e; }
"""


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", default="config.json",
                        help="chemin du fichier config")
    args = parser.parse_args()

    cfg = load_config(args.config)

    global JSON_PATH, GPX_DIR, TEMP_DIR, JS_PATH
    JSON_PATH = cfg["json_path"]
    GPX_DIR = Path(cfg["gpx_dir"])
    TEMP_DIR = cfg.get("temp_dir", "/tmp/gpx-studio-drop")
    JS_PATH = cfg.get("js_path")

    visible_columns = cfg.get("visible_columns", list(DEFAULT_VISIBLE))
    default_sort = cfg.get("default_sort", {"column": "jour", "descending": True})
    window_cfg = cfg.get("window", {})
    theme_cfg = cfg.get("theme", {})

    app = QApplication(sys.argv)
    win = MainWindow(JSON_PATH, visible_columns, default_sort,
                     config_path=args.config, window_cfg=window_cfg,
                     theme_cfg=theme_cfg)
    win.show()
    sys.exit(app.exec())


if __name__ == "__main__":
    main()

Parfait, l’import est donc opérationnel : sélection de plusieurs .gpx, géocodage hors du thread de l’interface, ajout au JSON et copie dans gpx_dir.

Deux idées si tu veux aller plus loin :

• Suppression des sources après import, comme dans ton script d’origine, avec une case à cocher dans le dialogue ou une clé dans config.json.
• Glisser-déposer entrant : déposer des .gpx sur la fenêtre pour lancer l’import, en réutilisant le même ImportWorker.

uv (recommandé)

Dans le dossier de tableauqt.py :

cd ~/media/dplus/cartographie/analyse-gpx     # adapter : là où se trouve tableau.py

Environnement

# Environnement et Pyside
uv venv --python /usr/bin/python              # Python système, donc tkinter garanti
uv pip install PySide6

Lancement

# lancement
uv run --no-project python tableauqt.py --config config.json
# ou directement :
.venv/bin/python tableauqt.py --config config.json

Une différence notable : sous Qt, le tri en mode “Afficher sélection” est géré par le proxy, donc trier en vue filtrée ne réordonne plus vos données sources, ce qui corrige un effet de bord présent dans la version tkinter.

Installer tableau

Créer le script ~/.local/bin/tableau :

#!/bin/sh
cd ~/media/dplus/cartographie/analyse-gpx || exit 1
exec .venv/bin/python tableauqt.py --config config.json "$@"

Le rendre exécutable

chmod +x ~/.local/bin/tableau

Lanceur KDE desktop ~/.local/share/applications/tableau-gpx.desktop

[Desktop Entry]
Categories=Utility;
Exec=/home/yann/.local/bin/tableau --config /home/yann/.config/tableau/config.json
Icon=/home/yann/.config/tableau/tableau-gpx.png
Name=Tableau GPX
NoDisplay=false
PrefersNonDefaultGPU=false
StartupNotify=true
Terminal=false
Type=Application
X-KDE-SubstituteUID=false

Remplacer /home/yann si autre utilisateur

Structure finale

~/.config/tableau

.config/tableau/
├── config.json
├── tableau-gpx.ico
└── tableau-gpx.png

Application tableau: ~/.local/bin/tableau
Lanceur KDE desktop ~/.local/share/applications/tableau-gpx.desktop