Documentation : SyncVision Pro

1. Présentation générale

SyncVision Pro est un utilitaire de synchronisation de fichiers unidirectionnel doté d’une interface graphique (GUI) développée avec Python et Tkinter. Il permet de copier le contenu d’un dossier source vers un dossier de destination en s’assurant que seuls les fichiers nouveaux ou modifiés sont transférés, optimisant ainsi le temps de traitement.

2. Fonctionnalités clés

Synchronisation Intelligente : Compare les fichiers par taille et par empreinte numérique (SHA-256) pour garantir l’intégrité des données.
Statistiques en Temps Réel : Affichage dynamique du nombre total de fichiers, des fichiers copiés et des fichiers ignorés.
Console Intégrée : Journalisation (log) détaillée des opérations en cours.
Multi-threading : L’interface reste fluide pendant le processus de synchronisation grâce à l’exécution en arrière-plan.
Persistance des Paramètres : Sauvegarde automatique des derniers chemins utilisés et de la taille de la fenêtre dans un fichier config.json.

3. Prérequis

Python 3.x installé.
Bibliothèques standards incluses (aucune installation pip externe n’est requise) :
- os, shutil, hashlib, json, tkinter, threading.

4. Structure du Code

Logique de calcul (`file_hash`)

La fonction file_hash(path, algo="sha256") lit les fichiers par blocs de 8192 octets pour générer une empreinte unique. Cela permet de détecter une modification de contenu même si le nom du fichier reste identique.

Interface Graphique (`SyncApp`)

setup_ui : Définit la mise en page (champs de saisie, barres de progression, zone de texte).
load_config / on_close : Gère la lecture et l’écriture de la configuration utilisateur.
start_sync_thread : Initialise les compteurs et lance le thread de travail pour ne pas figer l’application.

Processus de Synchronisation (`run_sync`)

Le script suit un flux de travail en deux étapes :

Inventaire : Scan récursif du dossier source pour lister tous les fichiers (ignore les fichiers/dossiers cachés commençant par un point).
Traitement : Pour chaque fichier, il vérifie si une copie est nécessaire selon trois critères :
- Le fichier n’existe pas dans la destination.
- La taille du fichier est différente.
- Le hash SHA-256 est différent.

5. Utilisation

Lancez le script via la commande : python app.py.
Source : Cliquez sur « Parcourir » pour sélectionner le dossier contenant vos fichiers originaux.
Destination : Sélectionnez le dossier où les fichiers doivent être sauvegardés.
Lancer : Cliquez sur le bouton vert « Lancer la synchronisation ».
Suivi : Observez la barre de progression et la console pour voir quels fichiers sont en cours de traitement.

6. Détails Techniques

Algorithme de comparaison : SHA-256.
Gestion des dossiers : Le script recrée automatiquement l’arborescence des sous-dossiers dans la destination si elle n’existe pas.
Sécurité : Utilise shutil.copy2 pour préserver au maximum les métadonnées des fichiers (dates de création/modification).

7. Limitations connues

Synchronisation unidirectionnelle : Le script ne supprime pas les fichiers dans la destination s’ils ont été supprimés de la source.
Fichiers système : Les fichiers cachés (commençant par .) sont ignorés par défaut.

Développé avec Python & Tkinter.

Source

Python

import os
import shutil
import hashlib
import json
import tkinter as tk
from tkinter import filedialog, messagebox, scrolledtext, ttk
import threading

# — Logique de calcul —

def file_hash(path, algo="sha256", chunk_size=8192):
    h = hashlib.new(algo)
    try:
        with open(path, "rb") as f:
            while chunk := f.read(chunk_size):
                h.update(chunk)
        return h.hexdigest()
    except Exception:
        return None

# — Interface Graphique —

class SyncApp:
    def __init__(self, root):
        self.root = root
        self.root.title("SyncVision Pro – Statistiques en direct")
        self.config_file = "config.json"
        
        self.src_path = tk.StringVar()
        self.dst_path = tk.StringVar()
        self.is_running = False

        # Variables pour les compteurs
        self.count_total = tk.IntVar(value=0)
        self.count_copied = tk.IntVar(value=0)
        self.count_skipped = tk.IntVar(value=0)

        self.load_config()
        self.setup_ui()
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)

    def setup_ui(self):
        # Configuration des styles
        style = ttk.Style()
        style.configure("TProgressbar", thickness=20)

        padding = {'padx': 15, 'pady': 8}

        # 1. Sélection des dossiers
        frame_top = tk.LabelFrame(self.root, text=" Paramètres de synchronisation ", padx=10, pady=10)
        frame_top.pack(fill='x', padx=15, pady=10)

        tk.Label(frame_top, text="Source :").grid(row=0, column=0, sticky='w')
        tk.Entry(frame_top, textvariable=self.src_path).grid(row=0, column=1, sticky='ew', padx=5)
        tk.Button(frame_top, text="Parcourir", command=lambda: self.browse_folder(self.src_path)).grid(row=0, column=2)

        tk.Label(frame_top, text="Destination :").grid(row=1, column=0, sticky='w')
        tk.Entry(frame_top, textvariable=self.dst_path).grid(row=1, column=1, sticky='ew', padx=5)
        tk.Button(frame_top, text="Parcourir", command=lambda: self.browse_folder(self.dst_path)).grid(row=1, column=2)
        frame_top.columnconfigure(1, weight=1)

        # 2. Zone des Statistiques (Nouveauté)
        frame_stats = tk.Frame(self.root)
        frame_stats.pack(fill='x', padx=15)
        
        tk.Label(frame_stats, text="Total : ").pack(side='left')
        tk.Label(frame_stats, textvariable=self.count_total, fg="blue", font=('bold')).pack(side='left', padx=(0, 20))
        
        tk.Label(frame_stats, text="Copiés : ").pack(side='left')
        tk.Label(frame_stats, textvariable=self.count_copied, fg="green", font=('bold')).pack(side='left', padx=(0, 20))
        
        tk.Label(frame_stats, text="Identiques : ").pack(side='left')
        tk.Label(frame_stats, textvariable=self.count_skipped, fg="gray", font=('bold')).pack(side='left')

        # 3. Barre de progression
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(self.root, variable=self.progress_var, maximum=100)
        self.progress_bar.pack(fill='x', padx=15, pady=(5, 10))

        # 4. Console
        self.log_area = scrolledtext.ScrolledText(self.root, height=12, state='disabled', bg="#1e1e1e", fg="#00ff00")
        self.log_area.pack(fill='both', expand=True, padx=15, pady=5)

        # 5. Bouton
        self.btn_sync = tk.Button(self.root, text="Lancer la synchronisation", 
                                  bg="#2ecc71", fg="white", font=('Segoe UI', 10, 'bold'),
                                  height=2, command=self.start_sync_thread)
        self.btn_sync.pack(fill='x', padx=15, pady=15)

    def log(self, message):
        self.log_area.configure(state='normal')
        self.log_area.insert(tk.END, message + "\n")
        self.log_area.see(tk.END)
        self.log_area.configure(state='disabled')

    def browse_folder(self, var):
        folder = filedialog.askdirectory()
        if folder: var.set(folder)

    def load_config(self):
        if os.path.exists(self.config_file):
            try:
                with open(self.config_file, 'r') as f:
                    config = json.load(f)
                    self.src_path.set(config.get("src", ""))
                    self.dst_path.set(config.get("dst", ""))
                    self.root.geometry(config.get("geometry", "850×650"))
            except: self.root.geometry("850×650")
        else: self.root.geometry("850×650")

    def on_close(self):
        config = {"src": self.src_path.get(), "dst": self.dst_path.get(), "geometry": self.root.winfo_geometry()}
        with open(self.config_file, 'w') as f: json.dump(config, f)
        self.root.destroy()

    def start_sync_thread(self):
        if not self.src_path.get() or not self.dst_path.get():
            messagebox.showwarning("Erreur", "Veuillez sélectionner les dossiers.")
            return
        if not self.is_running:
            # Réinitialisation des compteurs
            self.count_total.set(0)
            self.count_copied.set(0)
            self.count_skipped.set(0)
            
            self.is_running = True
            self.btn_sync.config(state='disabled', text="Analyse en cours…", bg="#95a5a6")
            threading.Thread(target=self.run_sync, daemon=True).start()

    def run_sync(self):
        src, dst = self.src_path.get(), self.dst_path.get()
        copied_val = 0
        skipped_val = 0
        
        try:
            # Étape 1 : Inventaire
            self.log("Scan de la source…")
            all_files = []
            for root_dir, dirs, files in os.walk(src):
                dirs[:] = [d for d in dirs if not d.startswith('.')]
                for f in files:
                    if not f.startswith('.'):
                        all_files.append(os.path.join(root_dir, f))
            
            total_val = len(all_files)
            self.count_total.set(total_val)
            
            if total_val == 0:
                self.log("Aucun fichier trouvé.")
                return

            self.btn_sync.config(text="Synchronisation en cours…")

            # Étape 2 : Traitement
            for i, src_file in enumerate(all_files):
                rel_path = os.path.relpath(src_file, src)
                dest_file_path = os.path.join(dst, rel_path)
                dest_dir = os.path.dirname(dest_file_path)
                
                os.makedirs(dest_dir, exist_ok=True)
                
                should_copy = False
                reason = ""
                
                # Vérification logique
                if not os.path.exists(dest_file_path):
                    should_copy, reason = True, "nouveau"
                else:
                    if os.path.getsize(src_file) != os.path.getsize(dest_file_path):
                        should_copy, reason = True, "taille"
                    elif file_hash(src_file) != file_hash(dest_file_path):
                        should_copy, reason = True, "hash"

                if should_copy:
                    self.log(f"[{reason.upper()}] {os.path.basename(src_file)}")
                    shutil.copy2(src_file, dest_file_path)
                    copied_val += 1
                    self.count_copied.set(copied_val)
                else:
                    skipped_val += 1
                    self.count_skipped.set(skipped_val)
                
                # Mise à jour barre de progression
                self.progress_var.set(((i + 1) / total_val) * 100)

            self.log(f"\nTerminé ! {copied_val} copiés, {skipped_val} ignorés.")
            messagebox.showinfo("SyncVision", "La synchronisation est terminée.")

        except Exception as e:
            self.log(f"Erreur : {e}")
            messagebox.showerror("Erreur", str(e))
        finally:
            self.is_running = False
            self.btn_sync.config(state='normal', text="Lancer la synchronisation", bg="#2ecc71")

if __name__ == "__main__":
    root = tk.Tk()
    app = SyncApp(root)
    root.mainloop()

Documentation : SyncVision Pro

Published by geo on 26 décembre 2025

1. Présentation générale

2. Fonctionnalités clés

3. Prérequis

4. Structure du Code

Logique de calcul (`file_hash`)

Interface Graphique (`SyncApp`)

Processus de Synchronisation (`run_sync`)

5. Utilisation

6. Détails Techniques

7. Limitations connues

Source

0 commentaire

Laisser un commentaire Annuler la réponse

SyncVision Pro (Mode Miroir)

Python et l’API Gemini (Google AI)

Gestionnaire automatique de connexion Wi-Fi

Documentation : SyncVision Pro

Published by geo on 26 décembre 2025

1. Présentation générale

2. Fonctionnalités clés

3. Prérequis

4. Structure du Code

Logique de calcul (file_hash)

Interface Graphique (SyncApp)

Processus de Synchronisation (run_sync)

5. Utilisation

6. Détails Techniques

7. Limitations connues

Source

0 commentaire

Laisser un commentaire Annuler la réponse

Articles similaires

SyncVision Pro (Mode Miroir)

Python et l’API Gemini (Google AI)

Gestionnaire automatique de connexion Wi-Fi

Logique de calcul (`file_hash`)

Interface Graphique (`SyncApp`)

Processus de Synchronisation (`run_sync`)