Merge pull request #25 from ZylosCore/logs-fix

Logs fix

Author: Ashraf-Khabar

project_info.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project>
     <name>BulkFolder</name>
-    <version>1.7.8</version>
+    <version>1.7.10</version>
     <description>The safest and fastest bulk organizer and renamer.</description>
     <author>Achraf KHABAR / Open Source Community</author>
     <repository>https://github.com/Ashraf-Khabar/bulkfolder</repository>

src/bulkfolder/executor.py

@@ -1,9 +1,23 @@
 from __future__ import annotations
 from pathlib import Path
+from typing import Callable, Optional
 from .domain import Plan, ActionType
 from .journal import JournalEntry, append_entries, journal_path_for, now_iso
 
-def apply_plan(plan: Plan, *, allow_conflicts: bool = False) -> int:
+def apply_plan(
+    plan: Plan, 
+    *, 
+    allow_conflicts: bool = False, 
+    on_progress: Optional[Callable[[str, str], None]] = None
+) -> int:
+    """
+    Applies the given plan by executing file operations.
+    
+    Args:
+        plan: The Plan object containing items to process.
+        allow_conflicts: If True, overwrites existing files.
+        on_progress: Optional callback function(message, level) for logging.
+    """
     if plan.has_conflicts and not allow_conflicts:
         raise RuntimeError("Plan has conflicts. Resolve before applying.")
 
@@ -16,15 +30,31 @@ def apply_plan(plan: Plan, *, allow_conflicts: bool = False) -> int:
             continue
 
         src, dst = item.src, item.dst
-        dst.parent.mkdir(parents=True, exist_ok=True)
-
-        if dst.exists() and not allow_conflicts:
-            raise FileExistsError(dst)
-
-        src.replace(dst)
-
-        entries.append(JournalEntry(op="move", src=str(src), dst=str(dst), ts=now_iso()))
-        applied += 1
+        
+        try:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+
+            if dst.exists() and not allow_conflicts:
+                if on_progress:
+                    on_progress(f"Conflict: {dst.name} already exists. Skipping.", "WARNING")
+                continue
+
+            src.replace(dst)
+            
+            # Logging the success of the operation
+            if on_progress:
+                on_progress(f"Moved: {src.name} -> {dst.parent.name}/", "SUCCESS")
+
+            entries.append(JournalEntry(op="move", src=str(src), dst=str(dst), ts=now_iso()))
+            applied += 1
+            
+        except Exception as e:
+            if on_progress:
+                on_progress(f"Error processing {src.name}: {str(e)}", "ERROR")
 
     append_entries(jpath, entries)
-    return applied
+    
+    if on_progress:
+        on_progress(f"Task completed. {applied} operations applied.", "INFO")
+        
+    return applied

src/bulkfolder/ui/actions.py

@@ -4,6 +4,7 @@
 import sys
 import shutil
 import webbrowser
+import threading
 from datetime import datetime
 from pathlib import Path
 from tkinter import filedialog, messagebox
@@ -76,55 +77,88 @@ def choose_folder(app) -> None:
 def toggle_subfolders(app, enabled: bool) -> None:
     app.ui_state.include_subfolders = enabled
 
-def toggle_move_by_ext(app, enabled: bool) -> None:
-    app.ui_state.move_by_ext = enabled
-
 def scan_and_plan(app) -> None:
-    """Scan folder and build virtual plan without Find/Replace rules."""
+    """Scan folder and build virtual plan in a background thread."""
     root = getattr(app.ui_state, "root", None)
     if not root:
         messagebox.showwarning("BulkFolder", "Please choose a folder first.")
         return
 
     app.set_status("Scanning...")
+    app.topbar_view.show_loading(True)
 
-    # 1. Scan drive
-    scanned = scan_folder(app.ui_state.root, include_subfolders=app.ui_state.include_subfolders)
-    app.last_scan = scanned
-
-    # 2. Apply Move rule only (Find/Replace removed)
-    move_rule = MoveByExtensionRule(DEFAULT_MAPPING) if app.ui_state.move_by_ext else None
-    plan = build_plan(app.ui_state.root, scanned, replace_rule=None, move_rule=move_rule)
-    app.last_plan = plan
-
-    # 3. Calculate statistics
-    files_count = sum(1 for x in scanned if x.is_file)
-    planned = sum(1 for it in plan.items if it.action.value != "skip")
-    conflicts = sum(1 for it in plan.items if it.conflict)
-    total_size = sum(x.size for x in scanned if x.is_file)
-
-    # 4. Update UI
-    app.cards_view.set_values(str(files_count), str(planned), str(conflicts), app.human_bytes(total_size))
-    app.preview_view.render(plan)
-    app.dashboard_view.render(scanned, mapping=DEFAULT_MAPPING)
-    
-    app.organizer_panel.set_apply_enabled((not plan.has_conflicts) and planned > 0)
-    app.organizer_panel.set_undo_enabled(True)
-    app.tabs.set("Preview")
+    def run_scan():
+        try:
+            # 1. Heavy Scanning Logic
+            scanned = scan_folder(app.ui_state.root, include_subfolders=app.ui_state.include_subfolders)
+            move_rule = MoveByExtensionRule(DEFAULT_MAPPING) if app.ui_state.move_by_ext else None
+            plan = build_plan(app.ui_state.root, scanned, replace_rule=None, move_rule=move_rule)
+            
+            # Statistics calculation
+            files_count = sum(1 for x in scanned if x.is_file)
+            planned = sum(1 for it in plan.items if it.action.value != "skip")
+            conflicts = sum(1 for it in plan.items if it.conflict)
+            total_size = sum(x.size for x in scanned if x.is_file)
+
+            # 2. Update UI back on main thread
+            app.after(0, lambda: finalize_scan(scanned, plan, files_count, planned, conflicts, total_size))
+            
+        except Exception as e:
+            app.after(0, lambda: handle_scan_error(str(e)))
+
+    def finalize_scan(scanned, plan, files_count, planned, conflicts, total_size):
+        app.last_scan = scanned
+        app.last_plan = plan
+        app.cards_view.set_values(str(files_count), str(planned), str(conflicts), app.human_bytes(total_size))
+        app.preview_view.render(plan)
+        app.dashboard_view.render(scanned, mapping=DEFAULT_MAPPING)
+        
+        app.organizer_panel.set_apply_enabled((not plan.has_conflicts) and planned > 0)
+        app.organizer_panel.set_undo_enabled(True)
+        app.tabs.set("Preview")
+        
+        app.topbar_view.show_loading(False)
+        app.set_status("Ready")
+        app.log(f"Scan complete: {files_count} files found.", level="INFO")
+
+    def handle_scan_error(error_msg: str):
+        app.topbar_view.show_loading(False)
+        app.set_status("Error during scan.")
+        messagebox.showerror("BulkFolder", f"Scan failed: {error_msg}")
+
+    # Start the background thread
+    threading.Thread(target=run_scan, daemon=True).start()
 
 def apply_plan(app) -> None:
-    """Physically apply changes."""
+    """Physically apply changes in background."""
     if not app.last_plan or sum(1 for it in app.last_plan.items if it.action.value != "skip") == 0: return
     if app.last_plan.has_conflicts:
         messagebox.showerror("BulkFolder", "Plan has conflicts.")
         return
+    
     if _ask_confirm(app, "BulkFolder", "Apply changes?"):
-        try:
-            n = exec_apply_plan(app.last_plan, allow_conflicts=False)
-            app.set_status("Applied.")
-            scan_and_plan(app)
-        except Exception as e:
-            messagebox.showerror("BulkFolder", f"Apply failed:\n{e}")
+        app.set_status("Applying changes...")
+        app.topbar_view.show_loading(True)
+
+        def run_apply():
+            try:
+                # Execution with our custom logging callback (UIState.log)
+                n = exec_apply_plan(app.last_plan, allow_conflicts=False, on_progress=app.log)
+                app.after(0, lambda: finalize_apply())
+            except Exception as e:
+                app.after(0, lambda: handle_apply_error(str(e)))
+
+        def finalize_apply():
+            app.topbar_view.show_loading(False)
+            app.set_status("Ready")
+            scan_and_plan(app) # Refresh after apply
+
+        def handle_apply_error(error_msg: str):
+            app.topbar_view.show_loading(False)
+            app.set_status("Error applying.")
+            messagebox.showerror("BulkFolder", f"Apply failed: {error_msg}")
+
+        threading.Thread(target=run_apply, daemon=True).start()
 
 def undo_last_ops(app) -> None:
     """Revert last applied operations."""
@@ -137,27 +171,29 @@ def undo_last_ops(app) -> None:
         except Exception as e:
             messagebox.showerror("BulkFolder", f"Undo failed:\n{e}")
 
-# Duplicates action remains in core but no longer called from Organizer Panel
 def find_duplicates_action(app) -> None:
-    """Scans for duplicate files."""
+    """Scans for duplicate files in background."""
     root = getattr(app.ui_state, "root", None)
     if not root: return
 
-    min_kb = int(app.settings.duplicate_min_size_kb) if getattr(app, "settings", None) else 1
-    scanned = app.last_scan or scan_folder(app.ui_state.root, include_subfolders=app.ui_state.include_subfolders)
-    app.last_scan = scanned
-    
-    groups = find_duplicates(scanned, min_size_bytes=min_kb * 1024)
-    ui_groups = [[str(p) for p in grp] for grp in groups]
-    
-    app.duplicates_view.render(ui_groups)
-    app.tabs.set("Duplicates")
+    app.set_status("Finding duplicates...")
+    app.topbar_view.show_loading(True)
 
+    def run_duplicates():
+        min_kb = int(app.settings.duplicate_min_size_kb) if getattr(app, "settings", None) else 1
+        scanned = app.last_scan or scan_folder(app.ui_state.root, include_subfolders=app.ui_state.include_subfolders)
+        groups = find_duplicates(scanned, min_size_bytes=min_kb * 1024)
+        ui_groups = [[str(p) for p in grp] for grp in groups]
+        
+        app.after(0, lambda: finalize_duplicates(ui_groups))
 
-# ==========================================
-# OTHER PAGES (CHUNKERS, FLATTENER, ETC.)
-# ==========================================
-# (Logic remains identical to original)
+    def finalize_duplicates(ui_groups):
+        app.duplicates_view.render(ui_groups)
+        app.tabs.set("Duplicates")
+        app.topbar_view.show_loading(False)
+        app.set_status("Ready")
+
+    threading.Thread(target=run_duplicates, daemon=True).start()
 
 def chunker_choose_folder(app) -> None:
     path = filedialog.askdirectory()
@@ -190,14 +226,22 @@ def chunker_apply(app) -> None:
     if not plan or not root: return
     if _ask_confirm(app, "Folder Splitter", f"Split this folder into {len(plan)} parts?"):
         app.set_status("Splitting folder...")
-        app.update()
-        success, errors = apply_chunks(root, plan)
-        if errors:
-            messagebox.showwarning("Partial Success", f"Moved: {success}\nErrors: {len(errors)}")
-        else:
-            messagebox.showinfo("Success", f"Successfully chunked folder!")
-        app.chunker_page.render_preview([])
-        app.chunker_plan = []
+        app.topbar_view.show_loading(True)
+        
+        def run_chunk():
+            success, errors = apply_chunks(root, plan)
+            app.after(0, lambda: finalize_chunk(success, errors))
+
+        def finalize_chunk(success, errors):
+            app.topbar_view.show_loading(False)
+            app.set_status("Ready")
+            if errors:
+                messagebox.showwarning("Partial Success", f"Moved: {success}\nErrors: {len(errors)}")
+            else:
+                messagebox.showinfo("Success", f"Successfully chunked folder!")
+            app.chunker_page.render_preview([])
+
+        threading.Thread(target=run_chunk, daemon=True).start()
 
 def flattener_choose_folder(app) -> None:
     path = filedialog.askdirectory()

src/bulkfolder/ui/app.py

@@ -72,7 +72,7 @@ def __init__(self, master, logo_path):
 
 class App(ctk.CTk):
     """
-    The main application window with a persistent bottom Terminal and Topbar toggle.
+    The main application window with multithreaded operations support.
     """
     def __init__(self):
         super().__init__()
@@ -137,7 +137,7 @@ def __init__(self):
         self.content_area.grid_rowconfigure(1, weight=1) 
         self.content_area.grid_rowconfigure(2, weight=0) 
 
-        # The Topbar now correctly handles the terminal toggle
+        # The Topbar handles status and loading animations
         self.topbar_view = TopbarView(self.content_area, on_toggle_sidebar=self.toggle_terminal)
         self.topbar_view.grid(row=0, column=0, sticky="ew", padx=18, pady=(18, 8))
 
@@ -150,6 +150,9 @@ def __init__(self):
         self.logs_view = LogsView(self.content_area, on_close=self.toggle_terminal)
         self.logs_view.grid(row=2, column=0, sticky="ew", padx=18, pady=(0, 18))
         self._terminal_visible = True
+        
+        # Link log view to state for global access
+        self.ui_state.log_view = self.logs_view
 
         self.pages: dict[str, ctk.CTkFrame] = {}
         self.pages["Organizer"] = self._build_page_organizer(self.page_container)
@@ -304,14 +307,14 @@ def toggle_terminal(self) -> None:
             self._terminal_visible = True
 
     def set_status(self, s: str) -> None:
+        """Updates the status in the top bar."""
         self.topbar_view.set_status(s)
 
     def log(self, s: str, level: str = "INFO") -> None:
         """
-        Global logging method.
+        Global logging method. Thread-safe log through UIState.
         """
-        if hasattr(self, "logs_view"): 
-            self.logs_view.log(s, level=level)
+        self.ui_state.log(s, level=level)
 
     @staticmethod
     def human_bytes(n: int) -> str:

src/bulkfolder/ui/state.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, Optional
 
 @dataclass
 class UIState:
+    """
+    Maintains the global state of the application UI and shared components.
+    """
     root: Path | None = None
     include_subfolders: bool = True
     find_text: str = ""
@@ -16,4 +20,14 @@ class UIState:
     empty_folders_root: Path | None = None
     unzipper_root: Path | None = None
     pdf_root: Path | None = None
-    chunker_root: Path | None = None
+    chunker_root: Path | None = None
+    
+    # Reference to the central log view component
+    log_view: Optional[Any] = None
+
+    def log(self, message: str, level: str = "INFO") -> None:
+        """
+        Helper method to send logs to the UI terminal if available.
+        """
+        if self.log_view and hasattr(self.log_view, "log"):
+            self.log_view.log(message, level)