FileSyncPRO.py

# ==========================================================
# FileSync PRO - Enterprise Backup & Sync Suite
# Professional Desktop Tool
# ==========================================================

import os
import sys
import shutil
import threading
import traceback
import hashlib
import zipfile
from datetime import datetime
from queue import Queue, Empty
from concurrent.futures import ThreadPoolExecutor

import tkinter as tk
from tkinter import filedialog, messagebox

import ttkbootstrap as tb
from ttkbootstrap.constants import *

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

from cryptography.fernet import Fernet


# =================== APP CONFIG ===================

APP_NAME = "FileSync PRO"
APP_VERSION = "4.0.0"


# =================== APP ===================

app = tk.Tk()
app.title(f"{APP_NAME} {APP_VERSION}")
app.geometry("1200x640")

tb.Style("darkly")


# =================== FLAGS ===================

ui_queue = Queue()

source_folder = tb.StringVar()
target_folder = tb.StringVar()

filter_ext = tb.StringVar(value="")
mirror_mode = tb.BooleanVar(value=False)
verify_hash = tb.BooleanVar(value=True)

zip_backup = tb.BooleanVar(value=False)
encrypt_backup = tb.BooleanVar(value=False)

sync_running = False
observer = None

files_synced = 0
bytes_copied = 0


# =================== UTIL ===================

def resource_path(file_name):
    base = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
    return os.path.join(base, file_name)

def log(msg):
    ui_queue.put(("log", msg))


def update_progress(v):
    ui_queue.put(("progress", v))


def update_stats():
    ui_queue.put(("stats", (files_synced, bytes_copied)))


def log_error():
    with open("error.log","a",encoding="utf-8") as f:
        f.write(traceback.format_exc()+"\n")


def hash_file(path):

    md5 = hashlib.md5()

    with open(path,"rb") as f:
        for chunk in iter(lambda:f.read(4096),b""):
            md5.update(chunk)

    return md5.hexdigest()


def allowed_file(file):

    ext = filter_ext.get().strip()

    if not ext:
        return True

    allowed = [e.strip().lower() for e in ext.split(",")]

    return os.path.splitext(file)[1].lower() in allowed


# =================== ENCRYPTION ===================

def generate_key():
    return Fernet.generate_key()


def encrypt_file(path):

    key = generate_key()
    fernet = Fernet(key)

    with open(path,"rb") as f:
        data = f.read()

    encrypted = fernet.encrypt(data)

    with open(path+".enc","wb") as f:
        f.write(encrypted)

    os.remove(path)

    return key


# =================== FILE COPY ===================

def sync_file(src_file, dst_file):

    global files_synced, bytes_copied

    try:

        os.makedirs(os.path.dirname(dst_file),exist_ok=True)

        copy_required = False

        if not os.path.exists(dst_file):
            copy_required = True

        else:

            if os.path.getmtime(src_file) > os.path.getmtime(dst_file):

                if verify_hash.get():

                    if hash_file(src_file) != hash_file(dst_file):
                        copy_required = True

                else:
                    copy_required = True

        if copy_required:

            shutil.copy2(src_file,dst_file)

            size = os.path.getsize(src_file)

            files_synced += 1
            bytes_copied += size

            log(f"✔ Synced: {os.path.basename(src_file)}")

    except:
        log_error()


# =================== MULTI THREAD SYNC ===================

def full_sync():

    global files_synced, bytes_copied

    if not source_folder.get() or not target_folder.get():
        messagebox.showerror("Error","Select folders first")
        return

    files_synced = 0
    bytes_copied = 0

    src = source_folder.get()
    dst = target_folder.get()

    log("🔄 Multi-thread synchronization started")

    file_list = []

    for root,dirs,files in os.walk(src):

        for f in files:

            if allowed_file(f):
                file_list.append(os.path.join(root,f))

    total = len(file_list)

    executor = ThreadPoolExecutor(max_workers=6)

    for i,src_file in enumerate(file_list):

        rel = os.path.relpath(src_file,src)
        dst_file = os.path.join(dst,rel)

        executor.submit(sync_file,src_file,dst_file)

        progress = int((i+1)/total*100)

        update_progress(progress)

    executor.shutdown(wait=True)

    update_stats()

    if mirror_mode.get():

        for root,dirs,files in os.walk(dst):

            for f in files:

                dst_file = os.path.join(root,f)

                rel = os.path.relpath(dst_file,dst)
                src_file = os.path.join(src,rel)

                if not os.path.exists(src_file):

                    os.remove(dst_file)

                    log(f"🗑 Deleted: {rel}")

    if zip_backup.get():
        create_zip_backup(dst)

    log("✅ Sync finished")
    update_progress(0)


# =================== ZIP BACKUP ===================

def create_zip_backup(folder):

    try:

        ts = datetime.now().strftime("%Y%m%d_%H%M%S")

        zip_path = f"{folder}_backup_{ts}.zip"

        log("📦 Creating ZIP backup")

        with zipfile.ZipFile(zip_path,"w",zipfile.ZIP_DEFLATED) as z:

            for root,dirs,files in os.walk(folder):

                for f in files:

                    file_path = os.path.join(root,f)

                    z.write(file_path,os.path.relpath(file_path,folder))

        log(f"📦 Backup created: {os.path.basename(zip_path)}")

        if encrypt_backup.get():

            encrypt_file(zip_path)

            log("🔐 Backup encrypted")

    except:
        log_error()


# =================== REAL TIME ===================

class SyncHandler(FileSystemEventHandler):

    def on_modified(self,event):

        if event.is_directory:
            return

        src = event.src_path

        if not allowed_file(src):
            return

        dst = os.path.join(
            target_folder.get(),
            os.path.relpath(src,source_folder.get())
        )

        sync_file(src,dst)


# =================== WATCH ===================

def start_realtime():

    global observer

    if not source_folder.get():
        return

    handler = SyncHandler()

    observer = Observer()

    observer.schedule(handler,source_folder.get(),recursive=True)

    observer.start()

    log("⚡ Real-time monitoring started")


def stop_realtime():

    global observer

    if observer:

        observer.stop()
        observer.join()

        observer = None

        log("🛑 Real-time monitoring stopped")


# =================== BROWSE ===================

def browse_source():

    folder = filedialog.askdirectory()

    if folder:
        source_folder.set(folder)


def browse_target():

    folder = filedialog.askdirectory()

    if folder:
        target_folder.set(folder)


# =================== ABOUT ===================

def show_about():

    messagebox.showinfo(
        f"About {APP_NAME}",
        f"{APP_NAME} v{APP_VERSION}\n\n"
        "Enterprise Backup & Synchronization Suite\n\n"
        "FileSync PRO is a professional desktop tool designed for\n"
        "developers, IT professionals, and power users who need\n"
        "fast, reliable, and automated file synchronization.\n\n"

        "Core Features:\n"
        "• ⚡ Real-time folder monitoring & instant sync\n"
        "• 🚀 High-performance multi-thread copy engine\n"
        "• 🧠 Smart hash verification for data integrity\n"
        "• 📦 Automatic ZIP archive backup creation\n"
        "• 🔐 Optional encrypted backup protection\n"
        "• 🎛 Advanced file extension filtering\n"
        "• 🗑 Mirror mode for full directory replication\n"
        "• 📊 Built-in synchronization analytics dashboard\n\n"

        "Built with:\n"
        "Python • Tkinter • ttkbootstrap • Watchdog\n\n"

        "Designed for backup automation, development workflows,\n"
        "server mirroring, and professional file management.\n\n"

        "© 2026 Mate Technologies\n"
        "https://matetools.gumroad.com"
    )


# =================== MENU ===================

menubar = tb.Menu(app)

help_menu = tb.Menu(menubar,tearoff=0)

help_menu.add_command(label="About",command=show_about)

menubar.add_cascade(label="Help",menu=help_menu)

app.config(menu=menubar)

try:
    app.iconbitmap(resource_path("logo.ico"))
except:
    pass

# =================== TITLE ===================

title_frame = tb.Frame(app)
title_frame.pack(pady=(12, 10))

tb.Label(
    title_frame,
    text=APP_NAME,
    font=("Segoe UI", 28, "bold"),
    bootstyle="primary"
).pack()

tb.Label(
    title_frame,
    text=f"v{APP_VERSION}  •  Enterprise Backup & Sync Suite",
    font=("Segoe UI", 10, "italic"),
    foreground="#9ca3af"
).pack(pady=(2, 6))

tb.Label(
    title_frame,
    text="Real-time file synchronization, automated backups, encryption, and high-performance multi-thread file transfer",
    font=("Segoe UI", 9),
    foreground="#6b7280"
).pack()


# =================== CONTROLS ===================

controls = tb.Labelframe(app,text="Controls",padding=10)
controls.pack(fill="x",padx=10,pady=6)

tb.Button(
    controls,
    text="🔄 Full Sync",
    bootstyle="success",
    command=lambda: threading.Thread(target=full_sync,daemon=True).start()
).pack(side="left",padx=5)

tb.Button(
    controls,
    text="⚡ Start Real-Time",
    bootstyle="warning",
    command=start_realtime
).pack(side="left",padx=5)

tb.Button(
    controls,
    text="🛑 Stop",
    bootstyle="danger",
    command=stop_realtime
).pack(side="left",padx=5)


# =================== SETTINGS ===================

settings = tb.Labelframe(app,text="Settings",padding=10)
settings.pack(fill="x",padx=10,pady=6)

tb.Label(settings,text="Source").pack(side="left")
tb.Entry(settings,textvariable=source_folder,width=35).pack(side="left",padx=5)
tb.Button(settings,text="Browse",command=browse_source).pack(side="left")

tb.Label(settings,text="Target").pack(side="left",padx=10)
tb.Entry(settings,textvariable=target_folder,width=35).pack(side="left",padx=5)
tb.Button(settings,text="Browse",command=browse_target).pack(side="left")

tb.Checkbutton(settings,text="Mirror",variable=mirror_mode).pack(side="left",padx=10)
tb.Checkbutton(settings,text="Verify Hash",variable=verify_hash).pack(side="left")

tb.Checkbutton(settings,text="ZIP Backup",variable=zip_backup).pack(side="left",padx=10)
tb.Checkbutton(settings,text="Encrypt Backup",variable=encrypt_backup).pack(side="left")


# =================== FILTER ===================

filter_frame = tb.Labelframe(app,text="File Filters",padding=10)
filter_frame.pack(fill="x",padx=10,pady=6)

tb.Label(filter_frame,text="Extensions (.txt,.pdf,.py)").pack(side="left")
tb.Entry(filter_frame,textvariable=filter_ext,width=40).pack(side="left",padx=10)


# =================== LOG ===================

log_frame = tb.Labelframe(app,text="Activity Log",padding=10)
log_frame.pack(fill="both",expand=True,padx=10,pady=6)

log_text = tk.Text(log_frame, height=10)
log_text.pack(side="left",fill="both",expand=True)

scroll = tk.Scrollbar(log_frame,command=log_text.yview)
scroll.pack(side="right",fill="y")

log_text.config(yscrollcommand=scroll.set,state="disabled")


# =================== PROGRESS ===================

progress = tb.Progressbar(app,bootstyle="success-striped")
progress.pack(fill="x",padx=10,pady=5)


# =================== STATS ===================

stats_label = tb.Label(app,text="Files synced: 0 | Data copied: 0 MB")
stats_label.pack()


# =================== UI QUEUE ===================

def process_ui_queue():

    try:

        while True:

            cmd,data = ui_queue.get_nowait()

            if cmd=="log":

                log_text.config(state="normal")
                log_text.insert("end",data+"\n")
                log_text.see("end")
                log_text.config(state="disabled")

            elif cmd=="progress":
                progress["value"] = data

            elif cmd=="stats":

                files,data_bytes = data

                mb = round(data_bytes/1024/1024,2)

                stats_label.config(
                    text=f"Files synced: {files} | Data copied: {mb} MB"
                )

    except Empty:
        pass

    app.after(100,process_ui_queue)


# =================== START ===================

app.after(100,process_ui_queue)

app.mainloop()