ocr_app.py

"""
PDF OCR Application
Converts scanned/image PDFs to searchable text PDFs using OCRmyPDF.
"""

import subprocess
import sys
import os
import threading
from pathlib import Path
from tkinter import filedialog, messagebox
import customtkinter as ctk

# Configure Tesseract and Ghostscript paths for Windows
TESSERACT_PATH = r"C:\Program Files\Tesseract-OCR"
GHOSTSCRIPT_PATH = r"C:\Program Files\gs\gs10.03.0\bin"

# Add both to PATH
extra_paths = []
if os.path.exists(TESSERACT_PATH):
    extra_paths.append(TESSERACT_PATH)
if os.path.exists(GHOSTSCRIPT_PATH):
    extra_paths.append(GHOSTSCRIPT_PATH)
if extra_paths:
    os.environ["PATH"] = os.pathsep.join(extra_paths) + os.pathsep + os.environ.get("PATH", "")


class OCRApp(ctk.CTk):
    def __init__(self):
        super().__init__()

        # Configure window
        self.title("PDF OCR Converter")
        self.geometry("600x500")
        self.minsize(500, 400)

        # Set appearance
        ctk.set_appearance_mode("dark")
        ctk.set_default_color_theme("blue")

        # Variables
        self.selected_files = []
        self.is_processing = False

        # Create UI
        self.create_widgets()

    def create_widgets(self):
        # Main container
        self.main_frame = ctk.CTkFrame(self, fg_color="transparent")
        self.main_frame.pack(fill="both", expand=True, padx=20, pady=20)

        # Title
        self.title_label = ctk.CTkLabel(
            self.main_frame,
            text="📄 PDF OCR Converter",
            font=ctk.CTkFont(size=28, weight="bold")
        )
        self.title_label.pack(pady=(0, 5))

        # Subtitle
        self.subtitle_label = ctk.CTkLabel(
            self.main_frame,
            text="Convert scanned PDFs to searchable text PDFs",
            font=ctk.CTkFont(size=14),
            text_color="gray"
        )
        self.subtitle_label.pack(pady=(0, 20))

        # Select files button
        self.select_btn = ctk.CTkButton(
            self.main_frame,
            text="📁 Select PDF Files",
            command=self.select_files,
            height=45,
            font=ctk.CTkFont(size=15)
        )
        self.select_btn.pack(fill="x", pady=(0, 15))

        # Files list frame
        self.files_frame = ctk.CTkFrame(self.main_frame)
        self.files_frame.pack(fill="both", expand=True, pady=(0, 15))

        self.files_label = ctk.CTkLabel(
            self.files_frame,
            text="Selected Files:",
            font=ctk.CTkFont(size=13, weight="bold"),
            anchor="w"
        )
        self.files_label.pack(fill="x", padx=10, pady=(10, 5))

        # Scrollable file list
        self.files_textbox = ctk.CTkTextbox(
            self.files_frame,
            height=150,
            font=ctk.CTkFont(size=12)
        )
        self.files_textbox.pack(fill="both", expand=True, padx=10, pady=(0, 10))
        self.files_textbox.insert("1.0", "No files selected...")
        self.files_textbox.configure(state="disabled")

        # Options frame
        self.options_frame = ctk.CTkFrame(self.main_frame, fg_color="transparent")
        self.options_frame.pack(fill="x", pady=(0, 15))

        # Language selection
        self.lang_label = ctk.CTkLabel(
            self.options_frame,
            text="OCR Language:",
            font=ctk.CTkFont(size=13)
        )
        self.lang_label.pack(side="left", padx=(0, 10))

        self.lang_var = ctk.StringVar(value="eng+ara")
        self.lang_dropdown = ctk.CTkOptionMenu(
            self.options_frame,
            variable=self.lang_var,
            values=["eng", "ara", "eng+ara", "deu", "fra", "spa", "chi_sim", "jpn"],
            width=150
        )
        self.lang_dropdown.pack(side="left")

        # Skip text checkbox
        self.skip_text_var = ctk.BooleanVar(value=True)
        self.skip_text_cb = ctk.CTkCheckBox(
            self.options_frame,
            text="Skip pages with text",
            variable=self.skip_text_var
        )
        self.skip_text_cb.pack(side="right")

        # Progress bar
        self.progress = ctk.CTkProgressBar(self.main_frame)
        self.progress.pack(fill="x", pady=(0, 10))
        self.progress.set(0)

        # Status label
        self.status_label = ctk.CTkLabel(
            self.main_frame,
            text="Ready",
            font=ctk.CTkFont(size=12),
            text_color="gray"
        )
        self.status_label.pack(pady=(0, 15))

        # Convert button
        self.convert_btn = ctk.CTkButton(
            self.main_frame,
            text="🚀 Convert to Searchable PDF",
            command=self.start_conversion,
            height=50,
            font=ctk.CTkFont(size=16, weight="bold"),
            fg_color="#2d8a2d",
            hover_color="#238a23"
        )
        self.convert_btn.pack(fill="x")

    def select_files(self):
        files = filedialog.askopenfilenames(
            title="Select PDF Files",
            filetypes=[("PDF files", "*.pdf"), ("All files", "*.*")]
        )
        if files:
            self.selected_files = list(files)
            self.update_file_list()

    def update_file_list(self):
        self.files_textbox.configure(state="normal")
        self.files_textbox.delete("1.0", "end")
        if self.selected_files:
            for i, f in enumerate(self.selected_files, 1):
                self.files_textbox.insert("end", f"{i}. {Path(f).name}\n")
        else:
            self.files_textbox.insert("1.0", "No files selected...")
        self.files_textbox.configure(state="disabled")

    def start_conversion(self):
        if not self.selected_files:
            messagebox.showwarning("No Files", "Please select PDF files first!")
            return

        if self.is_processing:
            return

        self.is_processing = True
        self.convert_btn.configure(state="disabled", text="Processing...")
        self.select_btn.configure(state="disabled")

        # Run conversion in a separate thread
        thread = threading.Thread(target=self.convert_files)
        thread.daemon = True
        thread.start()

    def convert_files(self):
        total = len(self.selected_files)
        successful = 0
        failed = []

        for i, input_file in enumerate(self.selected_files):
            input_path = Path(input_file)
            output_path = input_path.parent / f"{input_path.stem}_ocr.pdf"

            self.update_status(f"Processing {i+1}/{total}: {input_path.name}")
            self.update_progress((i) / total)

            try:
                # Build ocrmypdf command
                cmd = [
                    sys.executable, "-m", "ocrmypdf",
                    "-l", self.lang_var.get(),
                    "--output-type", "pdf"
                ]

                if self.skip_text_var.get():
                    cmd.append("--skip-text")

                cmd.extend([str(input_path), str(output_path)])

                # Run ocrmypdf
                result = subprocess.run(
                    cmd,
                    capture_output=True,
                    text=True,
                    creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
                )

                if result.returncode == 0:
                    successful += 1
                elif result.returncode == 6:  # Already has text
                    successful += 1  # Still counts as success
                else:
                    failed.append(f"{input_path.name}: {result.stderr[:100]}")

            except Exception as e:
                failed.append(f"{input_path.name}: {str(e)}")

        self.update_progress(1.0)
        self.finish_conversion(successful, total, failed)

    def update_status(self, text):
        self.after(0, lambda: self.status_label.configure(text=text))

    def update_progress(self, value):
        self.after(0, lambda: self.progress.set(value))

    def finish_conversion(self, successful, total, failed):
        def update_ui():
            self.is_processing = False
            self.convert_btn.configure(state="normal", text="🚀 Convert to Searchable PDF")
            self.select_btn.configure(state="normal")
            self.status_label.configure(text="Ready")

            if failed:
                msg = f"Converted {successful}/{total} files.\n\nFailed:\n" + "\n".join(failed[:5])
                if len(failed) > 5:
                    msg += f"\n... and {len(failed) - 5} more"
                messagebox.showwarning("Conversion Complete", msg)
            else:
                messagebox.showinfo("Success", f"Successfully converted {successful} file(s)!\n\nOutput files saved with '_ocr' suffix.")

        self.after(0, update_ui)


def check_tesseract():
    """Check if Tesseract is installed and accessible."""
    import shutil
    from tkinter import Tk, messagebox
    
    tesseract_path = shutil.which("tesseract")
    if tesseract_path is None:
        # Check common Windows installation paths
        common_paths = [
            r"C:\Program Files\Tesseract-OCR\tesseract.exe",
            r"C:\Program Files (x86)\Tesseract-OCR\tesseract.exe",
        ]
        for path in common_paths:
            if os.path.exists(path):
                return True
        
        # Tesseract not found - show error
        root = Tk()
        root.withdraw()
        messagebox.showerror(
            "Tesseract Not Found",
            "Tesseract OCR is required but not installed.\n\n"
            "Please install it from:\n"
            "https://github.com/UB-Mannheim/tesseract/wiki\n\n"
            "After installing, restart this application."
        )
        root.destroy()
        return False
    return True


def main():
    if not check_tesseract():
        return
    app = OCRApp()
    app.mainloop()


if __name__ == "__main__":
    main()