Automatic folder checking every 5 seconds Tooltips explain disabled buttons Progress bar with file size, total size, speed Cancel option for backups Multithreading for smooth UI USERPROFILE for reliable Windows paths

Automatic folder checking every 5 seconds

Tooltips explain disabled buttons

Progress bar with file size, total size, speed

Cancel option for backups

Multithreading for smooth UI

USERPROFILE for reliable Windows paths

Author: RandyNorthrup

Windows Backup/windows_backup.py

@@ -1,5 +1,89 @@
-import os, sys, glob, shutil
-from PySide6.QtWidgets import QMainWindow, QApplication, QPushButton, QWidget, QFileDialog, QMessageBox, QGridLayout
+import os, sys, shutil, time
+from PySide6.QtWidgets import (
+    QMainWindow, QApplication, QPushButton, QWidget, QFileDialog, QMessageBox,
+    QGridLayout, QProgressDialog, QSpacerItem, QSizePolicy
+)
+from PySide6.QtCore import Qt, QThread, Signal, QTimer
+
+
+def get_user_path(subpath=""):
+    """Return full path inside user's profile directory."""
+    user_profile = os.environ.get("USERPROFILE", "")
+    return os.path.join(user_profile, subpath) if subpath else user_profile
+
+
+class BackupWorker(QThread):
+    progress_update = Signal(int, str, int, int, float)
+    finished = Signal(int, bool, str)
+
+    def __init__(self, source_dir, destination_root, patterns):
+        super().__init__()
+        self.source_dir = source_dir
+        self.destination_root = destination_root
+        self.patterns = patterns
+        self.cancelled = False
+        self.files_copied = 0
+        self.total_size = 0
+        self.copied_size = 0
+        self.start_time = 0
+
+    def run(self):
+        try:
+            total_files, total_size = self.count_files()
+            self.total_size = total_size
+            if total_files == 0:
+                self.finished.emit(0, False, "No files found to backup.")
+                return
+
+            self.start_time = time.time()
+            files_processed = 0
+
+            for root, dirs, files in os.walk(self.source_dir):
+                if self.cancelled:
+                    break
+                rel_path = os.path.relpath(root, self.source_dir)
+                destination_folder = os.path.join(self.destination_root, rel_path)
+                os.makedirs(destination_folder, exist_ok=True)
+
+                for file in files:
+                    if any(file.lower().endswith(p.lstrip("*").lower()) for p in self.patterns):
+                        if self.cancelled:
+                            break
+                        source_file = os.path.join(root, file)
+                        dest_file = os.path.join(destination_folder, file)
+                        try:
+                            file_size = os.path.getsize(source_file)
+                            shutil.copy2(source_file, dest_file)
+                            self.files_copied += 1
+                            self.copied_size += file_size
+                        except Exception as e:
+                            self.finished.emit(self.files_copied, False, f"Failed to copy {file}: {e}")
+                            return
+                        files_processed += 1
+                        elapsed_time = time.time() - self.start_time
+                        speed = self.copied_size / (elapsed_time + 0.1)
+                        self.progress_update.emit(files_processed, file, file_size, self.copied_size, speed)
+
+            if self.cancelled:
+                self.finished.emit(self.files_copied, False, "Backup cancelled by user.")
+            else:
+                self.finished.emit(self.files_copied, True, "Backup completed successfully.")
+
+        except Exception as e:
+            self.finished.emit(self.files_copied, False, f"Backup failed: {e}")
+
+    def count_files(self):
+        count = 0
+        total_size = 0
+        for root, dirs, files in os.walk(self.source_dir):
+            for file in files:
+                if any(file.lower().endswith(p.lstrip("*").lower()) for p in self.patterns):
+                    count += 1
+                    total_size += os.path.getsize(os.path.join(root, file))
+        return count, total_size
+
+    def cancel(self):
+        self.cancelled = True
 
 
 class MainWindow(QMainWindow):
@@ -8,39 +92,64 @@ def __init__(self):
 
         self.setWindowTitle("Windows Backup Application")
         self.setFixedSize(800, 600)
-
-        # Define Backup Location Variable
-        self.backup_location = ""  # Set by User
+        self.backup_location = ""
 
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
         layout = QGridLayout()
         central_widget.setLayout(layout)
-        cols = 2
 
-        # Set Backup Location Button
+        # --- Alignment/spacing tweaks for clean layout ---
+        cols = 2
+        layout.setHorizontalSpacing(12)
+        layout.setVerticalSpacing(12)
+        layout.setContentsMargins(16, 16, 16, 16)
+        for c in range(cols):
+            layout.setColumnStretch(c, 1)
+        # -------------------------------------------------
+
+        # Set Backup Location Button (spans top row)
         self.backup_location_button = QPushButton("Set Backup Location", self)
         self.backup_location_button.clicked.connect(self.set_backup_location)
-        layout.addWidget(self.backup_location_button, 0, 0, 1, cols)  # Span top row
-
-        # Create Backup Buttons
+        layout.addWidget(self.backup_location_button, 0, 0, 1, cols)
+
+        # Map buttons to (source path, patterns, destination name)
+        self.backup_sources = {
+            "Backup Contacts": (get_user_path("Contacts"), ["*"], "Contacts"),
+            "Backup Photos": (get_user_path("Pictures"), ["*"], "Pictures"),
+            "Backup Documents": (get_user_path("Documents"), ["*"], "Documents"),
+            "Backup Videos": (get_user_path("Videos"), ["*"], "Videos"),
+            "Backup Music": (get_user_path("Music"), ["*"], "Music"),
+            "Backup Desktop": (get_user_path("Desktop"), ["*"], "Desktop"),
+            "Backup Downloads": (get_user_path("Downloads"), ["*"], "Downloads"),
+            "Backup Outlook Files": (get_user_path("AppData/Local/Microsoft/Outlook"),
+                                     ["*.pst", "*.ost", "*.nst"], "Outlook"),
+        }
+
+        # Create buttons in a predictable left-to-right, top-to-bottom order
         self.backup_buttons = []
-        self.backup_buttons.append(self.create_button("Backup Contacts", self.backup_contacts))
-        self.backup_buttons.append(self.create_button("Backup Photos", self.backup_photos))
-        self.backup_buttons.append(self.create_button("Backup Documents", self.backup_documents))
-        self.backup_buttons.append(self.create_button("Backup Videos", self.backup_videos))
-        self.backup_buttons.append(self.create_button("Backup Music", self.backup_music))
-        self.backup_buttons.append(self.create_button("Backup Desktop", self.backup_desktop))
-        self.backup_buttons.append(self.create_button("Backup Downloads", self.backup_downloads))
-        self.backup_buttons.append(self.create_button("Backup Outlook Files", self.backup_outlook_files))
-
-        # Add buttons to grid layout
-        for idx, btn in enumerate(self.backup_buttons):
-            btn.setFixedSize(150, 40)
+        for idx, (name, (src, pats, dest)) in enumerate(self.backup_sources.items()):
+            btn = self.create_button(name, lambda checked=False, n=name: self.start_backup(*self.backup_sources[n]))
+            btn.setFixedSize(180, 42)
             btn.setEnabled(False)
-            row = 1 + idx // cols
-            col = idx % cols
+            self.backup_buttons.append((btn, name))
+
+            # --- Correct grid placement (fixes orientation/alignment) ---
+            row = 1 + (idx // cols)      # first row after the header
+            col = idx % cols             # 0, 1, 0, 1, ...
             layout.addWidget(btn, row, col)
+            # ------------------------------------------------------------
+
+        # Add a flexible spacer row below buttons to keep them top-aligned
+        total_rows = 1 + ((len(self.backup_sources) + cols - 1) // cols)  # header + button rows
+        layout.setRowStretch(total_rows + 1, 1)
+        layout.addItem(QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.Expanding),
+                       total_rows + 1, 0, 1, cols)
+
+        # Auto-refresh timer every 5 seconds to re-check sources
+        self.refresh_timer = QTimer(self)
+        self.refresh_timer.timeout.connect(self.check_source_folders)
+        self.refresh_timer.start(5000)
 
     def create_button(self, text, command):
         btn = QPushButton(text, self)
@@ -51,62 +160,75 @@ def set_backup_location(self):
         folder = QFileDialog.getExistingDirectory(self, "Select Backup Location")
         if folder:
             self.backup_location = folder
-            for btn in self.backup_buttons:
-                btn.setEnabled(True)
-
-    def copy_with_glob(self, source_dir, destination_name, patterns=["*"]):
-        """Copy files matching patterns from source_dir to backup_location/destination_name"""
+            self.check_source_folders()
+
+    def check_source_folders(self):
+        """Enable buttons only if source exists and has files; set tooltips if disabled"""
+        for btn, name in self.backup_buttons:
+            src, patterns, dest = self.backup_sources[name]
+            folder_exists = os.path.exists(src)
+            has_files = folder_exists and any(
+                any(f.lower().endswith(p.lstrip("*").lower()) for f in files for p in patterns)
+                for _, _, files in os.walk(src)
+            )
+
+            if folder_exists and has_files:
+                if not btn.isEnabled():
+                    btn.setEnabled(True)
+                btn.setToolTip(f"Backup files from {src} → {dest}")
+            else:
+                if btn.isEnabled():
+                    btn.setEnabled(False)
+                if not folder_exists:
+                    btn.setToolTip(f"Source folder not found: {src}")
+                else:
+                    btn.setToolTip(f"No files found in {src} to backup")
+
+    def start_backup(self, source_dir, patterns, destination_name):
         if not self.backup_location:
             QMessageBox.warning(self, "Error", "Please set a backup location first.")
             return
 
-        source_dir = os.path.expanduser(source_dir)
         if not os.path.exists(source_dir):
             QMessageBox.warning(self, "Error", f"Source folder not found: {source_dir}")
             return
 
-        destination = os.path.join(self.backup_location, destination_name)
-        os.makedirs(destination, exist_ok=True)
-
-        files_copied = 0
-        for pattern in patterns:
-            for file_path in glob.glob(os.path.join(source_dir, pattern), recursive=True):
-                if os.path.isfile(file_path):  # only copy files, not directories
-                    try:
-                        shutil.copy2(file_path, destination)
-                        files_copied += 1
-                    except Exception as e:
-                        QMessageBox.warning(self, "Error", f"Failed to copy {file_path}: {e}")
-
-        if files_copied > 0:
-            QMessageBox.information(self, "Success", f"Backup of {files_copied} files completed in {destination_name}.")
+        destination_root = os.path.join(self.backup_location, destination_name)
+        os.makedirs(destination_root, exist_ok=True)
+
+        self.progress_dialog = QProgressDialog(f"Backing up {destination_name}...", "Cancel", 0, 100, self)
+        self.progress_dialog.setWindowModality(Qt.WindowModal)
+        self.progress_dialog.setMinimumWidth(420)
+        self.progress_dialog.setValue(0)
+
+        self.worker = BackupWorker(source_dir, destination_root, patterns)
+        self.worker.progress_update.connect(self.update_progress)
+        self.worker.finished.connect(self.backup_finished)
+        self.progress_dialog.canceled.connect(self.worker.cancel)
+
+        total_files, _ = self.worker.count_files()
+        self.progress_dialog.setMaximum(total_files if total_files > 0 else 1)
+
+        self.worker.start()
+
+    def update_progress(self, value, filename, file_size, copied_size, speed):
+        copied_mb = copied_size / (1024 * 1024)
+        total_mb = self.worker.total_size / (1024 * 1024) if self.worker.total_size else 0
+        speed_mb = speed / (1024 * 1024)
+        self.progress_dialog.setValue(value)
+        self.progress_dialog.setLabelText(
+            f"Copying: {filename}\n"
+            f"File size: {file_size / 1024:.1f} KB\n"
+            f"Copied: {copied_mb:.2f} / {total_mb:.2f} MB\n"
+            f"Speed: {speed_mb:.2f} MB/s"
+        )
+
+    def backup_finished(self, files_copied, success, message):
+        self.progress_dialog.close()
+        if success:
+            QMessageBox.information(self, "Success", f"{message}\n{files_copied} files backed up.")
         else:
-            QMessageBox.information(self, "Info", f"No files found in {source_dir} to backup.")
-
-    # Backup Methods
-    def backup_contacts(self):
-        self.copy_with_glob("~/Contacts", "Contacts")
-
-    def backup_photos(self):
-        self.copy_with_glob("~/Pictures", "Pictures")
-
-    def backup_documents(self):
-        self.copy_with_glob("~/Documents", "Documents")
-
-    def backup_videos(self):
-        self.copy_with_glob("~/Videos", "Videos")
-
-    def backup_music(self):
-        self.copy_with_glob("~/Music", "Music")
-
-    def backup_desktop(self):
-        self.copy_with_glob("~/Desktop", "Desktop")
-
-    def backup_downloads(self):
-        self.copy_with_glob("~/Downloads", "Downloads")
-
-    def backup_outlook_files(self):
-        self.copy_with_glob("~/AppData/Local/Microsoft/Outlook", "Outlook", ["*.pst", "*.ost", "*.nst"])
+            QMessageBox.warning(self, "Backup", message)
 
 
 if __name__ == "__main__":