Upload 4 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+parser_sevenof9_v1_de.exe filter=lfs diff=lfs merge=lfs -text
+parser_sevenof9_v1_en.exe filter=lfs diff=lfs merge=lfs -text

parser_sevenof9_v1_de.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c1157651ec219957876f09ec4acbf0d09f5f6469e986ab45c9d7f42df53b3ec
+size 25577192

parser_sevenof9_v1_de.py

@@ -0,0 +1,434 @@
+import os
+import sys
+import tkinter as tk
+from tkinter import filedialog, messagebox
+import subprocess
+import threading
+import tempfile
+import shutil
+import json
+import logging
+import pdfplumber
+from pdfplumber.utils import get_bbox_overlap, obj_to_bbox
+from pdfplumber.utils.exceptions import PdfminerException
+from joblib import delayed, cpu_count, parallel_backend, Parallel
+import multiprocessing  # Wichtig für frozen support
+from multiprocessing import Pool
+
+
+# ========================
+# Parser-Konfiguration
+# ========================
+
+TEXT_EXTRACTION_SETTINGS = {
+    "x_tolerance": 1,
+    "y_tolerance": 3,
+    "keep_blank_chars": False,
+    "use_text_flow": True
+}
+
+
+if sys.platform == "win32":
+    sys.stderr = open(os.devnull, 'w')
+
+PARALLEL_THRESHOLD = 16
+
+def suppress_pdfminer_logging():
+    for logger_name in [
+        "pdfminer",
+        "pdfminer.pdfparser",
+        "pdfminer.pdfdocument",
+        "pdfminer.pdfpage",
+        "pdfminer.converter",
+        "pdfminer.layout",
+        "pdfminer.cmapdb",
+        "pdfminer.utils"
+    ]:
+        logging.getLogger(logger_name).setLevel(logging.ERROR)
+
+def clean_cell_text(text):
+    if not isinstance(text, str):
+        return ""
+    text = text.replace("-\n", "").replace("\n", " ")
+    return " ".join(text.split())
+
+def safe_join(row):
+    return [clean_cell_text(str(cell)) if cell is not None else "" for cell in row]
+
+def clamp_bbox(bbox, page_width, page_height):
+    x0, top, x1, bottom = bbox
+    x0 = max(0, min(x0, page_width))
+    x1 = max(0, min(x1, page_width))
+    top = max(0, min(top, page_height))
+    bottom = max(0, min(bottom, page_height))
+    return (x0, top, x1, bottom)
+
+def process_page(args):
+
+    suppress_pdfminer_logging()
+    try:
+        page_number, pdf_path, text_settings = args
+        with pdfplumber.open(pdf_path) as pdf:
+            page = pdf.pages[page_number]
+            page_output = f"Page {page_number + 1}\n"
+            page_width = page.width
+            page_height = page.height
+
+            filtered_page = page
+            table_bbox_list = []
+            table_json_outputs = []
+
+            for table in page.find_tables():
+                bbox = clamp_bbox(table.bbox, page_width, page_height)
+                table_bbox_list.append(bbox)
+
+                if not page.crop(bbox).chars:
+                    continue
+
+                filtered_page = filtered_page.filter(
+                    lambda obj: get_bbox_overlap(obj_to_bbox(obj), bbox) is None
+                )
+
+                table_data = table.extract()
+                if table_data and len(table_data) >= 1:
+                    headers = safe_join(table_data[0])
+                    rows = [safe_join(row) for row in table_data[1:]]
+                    json_table = [dict(zip(headers, row)) for row in rows]
+                    table_json_outputs.append(json.dumps(json_table, indent=1, ensure_ascii=False))
+
+            chars_outside_tables = [
+                word for word in page.extract_words(**text_settings)
+                if not any(
+                    bbox[0] <= float(word['x0']) <= bbox[2] and
+                    bbox[1] <= float(word['top']) <= bbox[3]
+                    for bbox in table_bbox_list
+                )
+            ]
+
+            current_y = None
+            line = []
+            text_content = ""
+
+            for word in chars_outside_tables:
+                if current_y is None or abs(word['top'] - current_y) > 10:
+                    if line:
+                        text_content += " ".join(line) + "\n"
+                    line = [word['text']]
+                    current_y = word['top']
+                else:
+                    line.append(word['text'])
+            if line:
+                text_content += " ".join(line) + "\n"
+
+            page_output += text_content.strip() + "\n"
+
+            for idx, table in enumerate(table_json_outputs, start=1):
+                page_output += f'"tabelle {idx}":\n{table}\n'
+
+            return page_number, page_output
+
+    except Exception as e:
+        return args[0], f"[FEHLER] Seite {args[0]+1} ({args[1]}): {str(e)}"
+
+def verarbeite_pdf(pdf_path):
+    suppress_pdfminer_logging()
+    try:
+        if not os.path.exists(pdf_path):
+            return f"[FEHLER] Datei nicht gefunden: {pdf_path}"
+
+        print(f"[INFO] Beginne Verarbeitung: {pdf_path}")
+        try:
+            with pdfplumber.open(pdf_path) as pdf:
+                num_pages = len(pdf.pages)
+        except PdfminerException as e:
+            return f"[FEHLER] PDF kann nicht geöffnet werden: {pdf_path} – {str(e)}"
+        except Exception as e:
+            return f"[FEHLER] Allgemeiner Fehler beim Öffnen: {pdf_path} – {str(e)}"
+
+        pages = [(i, pdf_path, TEXT_EXTRACTION_SETTINGS) for i in range(num_pages)]
+
+        try:
+            results = run_serial(pages) if num_pages <= PARALLEL_THRESHOLD else run_parallel(pages)
+        except (EOFError, BrokenPipeError, KeyboardInterrupt):
+            return "[INFO] Verarbeitung wurde abgebrochen."
+
+        sorted_results = sorted(results, key=lambda x: x[0])
+        final_output = "\n".join(text for _, text in sorted_results)
+
+        base_name = os.path.splitext(os.path.basename(pdf_path))[0]
+        output_dir = os.path.dirname(pdf_path)
+        output_path = os.path.join(output_dir, f"{base_name}.txt")
+
+        with open(output_path, "w", encoding="utf-8", errors="ignore") as f:
+            f.write(final_output)
+
+        print(f"[INFO] Verarbeitung abgeschlossen: {output_path}")
+
+    except (EOFError, BrokenPipeError, KeyboardInterrupt):
+        return "[INFO] Verarbeitung durch Benutzer abgebrochen."
+    except Exception as e:
+        return f"[FEHLER] Unerwarteter Fehler bei '{pdf_path}': {str(e)}"
+
+def run_serial(pages):
+    return [process_page(args) for args in pages]
+
+def run_parallel(pages):
+    available_cores = max(1, cpu_count() - 2)  # Mindestens 1 Kern
+    num_cores = min(available_cores, len(pages))
+    print(f"Starte Parallelverarbeitung mit {num_cores} -2 Kernen...")
+    with Pool(processes=num_cores) as pool:
+        return pool.map(process_page, pages)
+
+def verarbeite_pdfs_main():
+    suppress_pdfminer_logging()
+    pdf_dateien = sys.argv[1:]
+    if not pdf_dateien:
+        print("Keine PDF-Dateien übergeben.")
+        return
+
+    kleine_pdfs = []
+    grosse_pdfs = []
+
+    for pfad in pdf_dateien:
+        if not os.path.exists(pfad):
+            print(f"Datei nicht gefunden: {pfad}")
+            continue
+        try:
+            with pdfplumber.open(pfad) as pdf:
+                if len(pdf.pages) <= PARALLEL_THRESHOLD:
+                    kleine_pdfs.append(pfad)
+                else:
+                    grosse_pdfs.append(pfad)
+        except PdfminerException:
+            print(f"[FEHLER] Passwortgeschützte PDF-Datei: {pfad} – wird übersprungen.")
+        except Exception as e:
+            print(f"[FEHLER] Fehler beim Öffnen von {pfad}: {str(e)}")
+
+    if kleine_pdfs:
+        available_cores = max(1, cpu_count() - 2)
+        num_cores = min(available_cores, len(kleine_pdfs))
+        print(f"\n[Phase 1] Starte Parallelverarbeitung kleiner PDFs mit {num_cores} -2 Kernen...")
+        results = Parallel(n_jobs=num_cores)(
+            delayed(verarbeite_pdf)(pfad) for pfad in kleine_pdfs
+        )
+        for r in results:
+            print(r)
+
+    for pfad in grosse_pdfs:
+        print(f"\n[Phase 2] Verarbeitung großer PDFs: {os.path.basename(pfad)}")
+        print(verarbeite_pdf(pfad))
+
+
+
+# ========================
+# GUI-Klasse
+# ========================
+
+class DateiManager:
+    def __init__(self, master):
+        self.master = master
+        self.master.title("Parser-Sevenof9")
+        self.dateien = []
+        self.last_selected_index = None
+
+        self.label = tk.Label(master, text="Ausgewählte PDF-Dateien:")
+        self.label.pack(pady=5)
+
+        listbox_frame = tk.Frame(master)
+        listbox_frame.pack(pady=5)
+
+        scrollbar_listbox = tk.Scrollbar(listbox_frame)
+        self.listbox = tk.Listbox(listbox_frame, selectmode=tk.MULTIPLE, width=80, height=6, yscrollcommand=scrollbar_listbox.set)
+        scrollbar_listbox.config(command=self.listbox.yview)
+
+        self.listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar_listbox.pack(side=tk.RIGHT, fill=tk.Y)
+
+        self.listbox.bind("<<ListboxSelect>>", self.zeige_textdatei)
+        self.listbox.bind("<Button-1>", self.on_listbox_click)
+        self.listbox.bind("<Shift-Button-1>", self.on_listbox_shift_click)
+
+        self.context_menu = tk.Menu(master, tearoff=0)
+        self.context_menu.add_command(label="Ausgewählte entfernen", command=self.datei_entfernen)
+        self.listbox.bind("<Button-3>", self.show_context_menu)
+
+        self.frame = tk.Frame(master)
+        self.frame.pack(pady=10)
+
+        tk.Button(self.frame, text="Ordner hinzufügen", command=self.ordner_hinzufuegen).pack(side=tk.LEFT, padx=5)
+        tk.Button(self.frame, text="Dateien auswählen", command=self.datei_hinzufuegen).pack(side=tk.LEFT, padx=5)
+        tk.Button(self.frame, text="Ausgewählte entfernen", command=self.datei_entfernen).pack(side=tk.LEFT, padx=5)
+        tk.Button(self.frame, text="Alle entfernen", command=self.alle_entfernen).pack(side=tk.LEFT, padx=5)
+        tk.Button(master, text="Stop", command=self.parser_stoppen).pack(pady=5)
+        self.parser_process = None  # Wird im Thread gespeichert
+
+        tk.Button(master, text="Parser starten", command=self.parser_starten).pack(pady=10)
+
+        textfeld_frame = tk.Frame(master)
+        textfeld_frame.pack(padx=10, pady=5)
+
+        scrollbar_textfeld = tk.Scrollbar(textfeld_frame)
+        self.textfeld = tk.Text(textfeld_frame, height=15, width=100, wrap=tk.WORD, yscrollcommand=scrollbar_textfeld.set)
+        scrollbar_textfeld.config(command=self.textfeld.yview)
+
+        self.textfeld.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar_textfeld.pack(side=tk.RIGHT, fill=tk.Y)
+
+        tk.Label(master, text="Fortschritt:").pack()
+
+        progress_frame = tk.Frame(master)
+        progress_frame.pack(padx=10, pady=5)
+
+        scrollbar_progress = tk.Scrollbar(progress_frame)
+        self.progress_text = tk.Text(progress_frame, height=8, width=100, state=tk.DISABLED, yscrollcommand=scrollbar_progress.set)
+        scrollbar_progress.config(command=self.progress_text.yview)
+
+        self.progress_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar_progress.pack(side=tk.RIGHT, fill=tk.Y)
+
+    def on_listbox_click(self, event):
+        index = self.listbox.nearest(event.y)
+        self.listbox.selection_clear(0, tk.END)
+        self.listbox.selection_set(index)
+        self.last_selected_index = index
+        self.zeige_textdatei(None)
+        return "break"
+
+    def on_listbox_shift_click(self, event):
+        index = self.listbox.nearest(event.y)
+        if self.last_selected_index is None:
+            self.last_selected_index = index
+        start, end = sorted((self.last_selected_index, index))
+        self.listbox.selection_clear(0, tk.END)
+        for i in range(start, end + 1):
+            self.listbox.selection_set(i)
+        return "break"
+
+    def show_context_menu(self, event):
+        if self.listbox.curselection():
+            self.context_menu.tk_popup(event.x_root, event.y_root)
+
+    def ordner_hinzufuegen(self):
+        ordner = filedialog.askdirectory(title="Ordner auswählen")
+        if not ordner:
+            return
+        for root, _, files in os.walk(ordner):
+            for file in files:
+                if file.lower().endswith(".pdf"):
+                    pfad = os.path.join(root, file)
+                    if pfad not in self.dateien:
+                        self.dateien.append(pfad)
+                        self.listbox.insert(tk.END, pfad)
+    
+    def datei_hinzufuegen(self):
+        pfade = filedialog.askopenfilenames(title="PDF-Dateien auswählen", filetypes=[("PDF-Dateien", "*.pdf")])
+        for pfad in pfade:
+            if pfad not in self.dateien:
+                self.dateien.append(pfad)
+                self.listbox.insert(tk.END, pfad)
+
+    def datei_entfernen(self):
+        selektion = self.listbox.curselection()
+        if not selektion:
+            messagebox.showwarning("Hinweis", "Bitte wählen Sie einen Eintrag zum Entfernen.")
+            return
+        for index in reversed(selektion):
+            self.listbox.delete(index)
+            del self.dateien[index]
+        self.textfeld.delete(1.0, tk.END)
+
+    def alle_entfernen(self):
+        self.listbox.delete(0, tk.END)
+        self.dateien.clear()
+        self.textfeld.delete(1.0, tk.END)
+        
+
+    def parser_starten(self):
+        if not self.dateien:
+            messagebox.showinfo("Keine Dateien", "Bitte wählen Sie mindestens eine Datei aus.")
+            return
+        self.progress_text.config(state=tk.NORMAL)
+        self.progress_text.delete(1.0, tk.END)
+        self.progress_text.insert(tk.END, "Starte Parser...\n")
+        self.progress_text.config(state=tk.DISABLED)
+        thread = threading.Thread(target=self.parser_ausfuehren)
+        thread.start()
+
+    def parser_stoppen(self):
+        if self.parser_process and self.parser_process.poll() is None:
+            self.parser_process.terminate()
+            self.progress_text_einfuegen("Parser-Prozess wurde gestoppt.\n")
+        else:
+            self.progress_text_einfuegen("Kein laufender Parser-Prozess zum Stoppen.\n")
+
+    def parser_ausfuehren(self):
+        try:
+            self.parser_process = subprocess.Popen(
+                [sys.executable, __file__] + self.dateien,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                encoding='utf-8',
+                errors='ignore',
+                bufsize=4096
+            )
+            for line in self.parser_process.stdout:
+                self.progress_text_einfuegen(line)
+            self.parser_process.stdout.close()
+            self.parser_process.wait()
+
+            if self.parser_process.returncode == 0:
+                self.progress_text_einfuegen("\nParser abgeschlossen.\n")
+                self.show_messagebox_threadsafe("Parser abgeschlossen", "Der Parser wurde erfolgreich ausgeführt.")
+            else:
+                self.progress_text_einfuegen("\nFehler beim Ausführen des Parsers.\n")
+                self.show_messagebox_threadsafe("Fehler", "Fehler beim Ausführen des Parsers.")
+        except Exception as e:
+            self.progress_text_einfuegen(f"Fehler: {e}\n")
+            self.show_messagebox_threadsafe("Fehler", f"Fehler beim Ausführen:\n{e}")
+        finally:
+            self.parser_process = None
+
+    def progress_text_einfuegen(self, text):
+        self.progress_text.after(0, lambda: self._text_einfuegen(text))
+
+    def _text_einfuegen(self, text):
+        self.progress_text.config(state=tk.NORMAL)
+        self.progress_text.insert(tk.END, text)
+        self.progress_text.see(tk.END)
+        self.progress_text.config(state=tk.DISABLED)
+
+    def show_messagebox_threadsafe(self, titel, nachricht):
+        self.master.after(0, lambda: messagebox.showinfo(titel, nachricht))
+
+    def zeige_textdatei(self, event):
+        selektion = self.listbox.curselection()
+        if not selektion:
+            return
+        index = selektion[0]
+        pfad = self.dateien[index]
+        txt_pfad = os.path.splitext(pfad)[0] + ".txt"
+        self.textfeld.delete(1.0, tk.END)
+        if os.path.exists(txt_pfad):
+            try:
+                with open(txt_pfad, "r", encoding="utf-8", errors="ignore") as f:
+                    self.textfeld.insert(tk.END, f.read())
+            except Exception as e:
+                self.textfeld.insert(tk.END, f"Fehler beim Laden der Textdatei:\n{e}")
+        else:
+            self.textfeld.insert(tk.END, "[Keine zugehörige .txt-Datei vorhanden]")
+
+# ========================
+# Einstiegspunkt
+# ========================
+
+
+if __name__ == "__main__":
+    multiprocessing.freeze_support()  # Muss als erstes im main stehen
+
+    if len(sys.argv) > 1:
+        verarbeite_pdfs_main()
+    else:
+        root = tk.Tk()
+        app = DateiManager(root)
+        root.mainloop()

parser_sevenof9_v1_en.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d8187a2413c1e5d9db9bd2d2eb21e9e811d82b42d63a4245d1d5a900172e6dc
+size 25576676

parser_sevenof9_v1_en.py

@@ -0,0 +1,429 @@
+import os
+import sys
+import tkinter as tk # internal
+from tkinter import filedialog, messagebox # internal
+import subprocess
+import threading
+import tempfile
+import shutil
+import json
+import logging
+import pdfplumber
+from pdfplumber.utils import get_bbox_overlap, obj_to_bbox
+from pdfplumber.utils.exceptions import PdfminerException
+from joblib import delayed, cpu_count, parallel_backend, Parallel
+import multiprocessing # intternal
+from multiprocessing import Pool # internal
+
+
+# ========================
+# Parser Configuration
+# ========================
+
+TEXT_EXTRACTION_SETTINGS = {
+    "x_tolerance": 1,
+    "y_tolerance": 3,
+    "keep_blank_chars": False,
+    "use_text_flow": True
+}
+
+if sys.platform == "win32":
+    sys.stderr = open(os.devnull, 'w')
+
+PARALLEL_THRESHOLD = 16
+
+def suppress_pdfminer_logging():
+    for logger_name in [
+        "pdfminer",
+        "pdfminer.pdfparser",
+        "pdfminer.pdfdocument",
+        "pdfminer.pdfpage",
+        "pdfminer.converter",
+        "pdfminer.layout",
+        "pdfminer.cmapdb",
+        "pdfminer.utils"
+    ]:
+        logging.getLogger(logger_name).setLevel(logging.ERROR)
+
+def clean_cell_text(text):
+    if not isinstance(text, str):
+        return ""
+    text = text.replace("-\n", "").replace("\n", " ")
+    return " ".join(text.split())
+
+def safe_join(row):
+    return [clean_cell_text(str(cell)) if cell is not None else "" for cell in row]
+
+def clamp_bbox(bbox, page_width, page_height):
+    x0, top, x1, bottom = bbox
+    x0 = max(0, min(x0, page_width))
+    x1 = max(0, min(x1, page_width))
+    top = max(0, min(top, page_height))
+    bottom = max(0, min(bottom, page_height))
+    return (x0, top, x1, bottom)
+
+def process_page(args):
+    suppress_pdfminer_logging()
+    try:
+        page_number, pdf_path, text_settings = args
+        with pdfplumber.open(pdf_path) as pdf:
+            page = pdf.pages[page_number]
+            output = f"Page {page_number + 1}\n"
+            width, height = page.width, page.height
+
+            filtered_page = page
+            table_bboxes = []
+            table_json_outputs = []
+
+            for table in page.find_tables():
+                bbox = clamp_bbox(table.bbox, width, height)
+                table_bboxes.append(bbox)
+
+                if not page.crop(bbox).chars:
+                    continue
+
+                filtered_page = filtered_page.filter(
+                    lambda obj: get_bbox_overlap(obj_to_bbox(obj), bbox) is None
+                )
+
+                table_data = table.extract()
+                if table_data and len(table_data) >= 1:
+                    headers = safe_join(table_data[0])
+                    rows = [safe_join(row) for row in table_data[1:]]
+                    json_table = [dict(zip(headers, row)) for row in rows]
+                    table_json_outputs.append(json.dumps(json_table, indent=1, ensure_ascii=False))
+
+            words_outside_tables = [
+                word for word in page.extract_words(**text_settings)
+                if not any(
+                    bbox[0] <= float(word['x0']) <= bbox[2] and
+                    bbox[1] <= float(word['top']) <= bbox[3]
+                    for bbox in table_bboxes
+                )
+            ]
+
+            current_y = None
+            line = []
+            text_content = ""
+
+            for word in words_outside_tables:
+                if current_y is None or abs(word['top'] - current_y) > 10:
+                    if line:
+                        text_content += " ".join(line) + "\n"
+                    line = [word['text']]
+                    current_y = word['top']
+                else:
+                    line.append(word['text'])
+            if line:
+                text_content += " ".join(line) + "\n"
+
+            output += text_content.strip() + "\n"
+
+            for idx, table in enumerate(table_json_outputs, start=1):
+                output += f'"table {idx}":\n{table}\n'
+
+            return page_number, output
+
+    except Exception as e:
+        return args[0], f"[ERROR] Page {args[0]+1} ({args[1]}): {str(e)}"
+
+def process_pdf(pdf_path):
+    suppress_pdfminer_logging()
+    try:
+        if not os.path.exists(pdf_path):
+            return f"[ERROR] File not found: {pdf_path}"
+
+        print(f"[INFO] Starting processing: {pdf_path}")
+        try:
+            with pdfplumber.open(pdf_path) as pdf:
+                num_pages = len(pdf.pages)
+        except PdfminerException as e:
+            return f"[ERROR] Cannot open PDF: {pdf_path} – {str(e)}"
+        except Exception as e:
+            return f"[ERROR] General error opening PDF: {pdf_path} – {str(e)}"
+
+        pages = [(i, pdf_path, TEXT_EXTRACTION_SETTINGS) for i in range(num_pages)]
+
+        try:
+            results = run_serial(pages) if num_pages <= PARALLEL_THRESHOLD else run_parallel(pages)
+        except (EOFError, BrokenPipeError, KeyboardInterrupt):
+            return "[INFO] Processing was interrupted."
+
+        sorted_results = sorted(results, key=lambda x: x[0])
+        final_output = "\n".join(text for _, text in sorted_results)
+
+        base_name = os.path.splitext(os.path.basename(pdf_path))[0]
+        output_dir = os.path.dirname(pdf_path)
+        output_path = os.path.join(output_dir, f"{base_name}.txt")
+
+        with open(output_path, "w", encoding="utf-8", errors="ignore") as f:
+            f.write(final_output)
+
+        print(f"[INFO] Processing complete: {output_path}")
+
+    except (EOFError, BrokenPipeError, KeyboardInterrupt):
+        return "[INFO] Processing interrupted by user."
+    except Exception as e:
+        return f"[ERROR] Unexpected error with '{pdf_path}': {str(e)}"
+
+def run_serial(pages):
+    return [process_page(args) for args in pages]
+
+def run_parallel(pages):
+    available_cores = max(1, cpu_count() - 2)
+    num_cores = min(available_cores, len(pages))
+    print(f"Starting parallel processing with {num_cores} cores...")
+    with Pool(processes=num_cores) as pool:
+        return pool.map(process_page, pages)
+
+def process_pdfs_main():
+    suppress_pdfminer_logging()
+    pdf_files = sys.argv[1:]
+    if not pdf_files:
+        print("No PDF files provided.")
+        return
+
+    small_pdfs = []
+    large_pdfs = []
+
+    for path in pdf_files:
+        if not os.path.exists(path):
+            print(f"File not found: {path}")
+            continue
+        try:
+            with pdfplumber.open(path) as pdf:
+                if len(pdf.pages) <= PARALLEL_THRESHOLD:
+                    small_pdfs.append(path)
+                else:
+                    large_pdfs.append(path)
+        except PdfminerException:
+            print(f"[ERROR] Password-protected PDF skipped: {path}")
+        except Exception as e:
+            print(f"[ERROR] Error opening {path}: {str(e)}")
+
+    if small_pdfs:
+        available_cores = max(1, cpu_count() - 2)
+        num_cores = min(available_cores, len(small_pdfs))
+        print(f"\n[Phase 1] Starting parallel processing of small PDFs with {num_cores} cores...")
+        results = Parallel(n_jobs=num_cores)(
+            delayed(process_pdf)(path) for path in small_pdfs
+        )
+        for r in results:
+            print(r)
+
+    for path in large_pdfs:
+        print(f"\n[Phase 2] Processing large PDF: {os.path.basename(path)}")
+        print(process_pdf(path))
+
+
+# ========================
+# GUI Class
+# ========================
+
+class FileManager:
+    def __init__(self, master):
+        self.master = master
+        self.master.title("Parser-Sevenof9")
+        self.files = []
+        self.last_selected_index = None
+
+        self.label = tk.Label(master, text="Selected PDF files:")
+        self.label.pack(pady=5)
+
+        listbox_frame = tk.Frame(master)
+        listbox_frame.pack(pady=5)
+
+        scrollbar_listbox = tk.Scrollbar(listbox_frame)
+        self.listbox = tk.Listbox(listbox_frame, selectmode=tk.MULTIPLE, width=80, height=6, yscrollcommand=scrollbar_listbox.set)
+        scrollbar_listbox.config(command=self.listbox.yview)
+
+        self.listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar_listbox.pack(side=tk.RIGHT, fill=tk.Y)
+
+        self.listbox.bind("<<ListboxSelect>>", self.show_text_file)
+        self.listbox.bind("<Button-1>", self.on_listbox_click)
+        self.listbox.bind("<Shift-Button-1>", self.on_listbox_shift_click)
+
+        self.context_menu = tk.Menu(master, tearoff=0)
+        self.context_menu.add_command(label="Remove selected", command=self.remove_file)
+        self.listbox.bind("<Button-3>", self.show_context_menu)
+
+        self.frame = tk.Frame(master)
+        self.frame.pack(pady=10)
+
+        tk.Button(self.frame, text="Add Folder", command=self.add_folder).pack(side=tk.LEFT, padx=5)
+        tk.Button(self.frame, text="Select Files", command=self.add_file).pack(side=tk.LEFT, padx=5)
+        tk.Button(self.frame, text="Remove Selected", command=self.remove_file).pack(side=tk.LEFT, padx=5)
+        tk.Button(self.frame, text="Remove All", command=self.remove_all).pack(side=tk.LEFT, padx=5)
+        tk.Button(master, text="Stop", command=self.stop_parser).pack(pady=5)
+        self.parser_process = None  # Will be stored in thread
+
+        tk.Button(master, text="Start Parser", command=self.start_parser).pack(pady=10)
+
+        text_frame = tk.Frame(master)
+        text_frame.pack(padx=10, pady=5)
+
+        scrollbar_text = tk.Scrollbar(text_frame)
+        self.text_widget = tk.Text(text_frame, height=15, width=100, wrap=tk.WORD, yscrollcommand=scrollbar_text.set)
+        scrollbar_text.config(command=self.text_widget.yview)
+
+        self.text_widget.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar_text.pack(side=tk.RIGHT, fill=tk.Y)
+
+        tk.Label(master, text="Progress:").pack()
+
+        progress_frame = tk.Frame(master)
+        progress_frame.pack(padx=10, pady=5)
+
+        scrollbar_progress = tk.Scrollbar(progress_frame)
+        self.progress_text = tk.Text(progress_frame, height=8, width=100, state=tk.DISABLED, yscrollcommand=scrollbar_progress.set)
+        scrollbar_progress.config(command=self.progress_text.yview)
+
+        self.progress_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar_progress.pack(side=tk.RIGHT, fill=tk.Y)
+
+    def on_listbox_click(self, event):
+        index = self.listbox.nearest(event.y)
+        self.listbox.selection_clear(0, tk.END)
+        self.listbox.selection_set(index)
+        self.last_selected_index = index
+        self.show_text_file(None)
+        return "break"
+
+    def on_listbox_shift_click(self, event):
+        index = self.listbox.nearest(event.y)
+        if self.last_selected_index is None:
+            self.last_selected_index = index
+        start, end = sorted((self.last_selected_index, index))
+        self.listbox.selection_clear(0, tk.END)
+        for i in range(start, end + 1):
+            self.listbox.selection_set(i)
+        return "break"
+
+    def show_context_menu(self, event):
+        if self.listbox.curselection():
+            self.context_menu.tk_popup(event.x_root, event.y_root)
+
+    def add_folder(self):
+        folder = filedialog.askdirectory(title="Select Folder")
+        if not folder:
+            return
+        for root, _, files in os.walk(folder):
+            for file in files:
+                if file.lower().endswith(".pdf"):
+                    path = os.path.join(root, file)
+                    if path not in self.files:
+                        self.files.append(path)
+                        self.listbox.insert(tk.END, path)
+
+    def add_file(self):
+        paths = filedialog.askopenfilenames(title="Select PDF Files", filetypes=[("PDF Files", "*.pdf")])
+        for path in paths:
+            if path not in self.files:
+                self.files.append(path)
+                self.listbox.insert(tk.END, path)
+
+    def remove_file(self):
+        selection = self.listbox.curselection()
+        if not selection:
+            messagebox.showwarning("Notice", "Please select an entry to remove.")
+            return
+        for index in reversed(selection):
+            self.listbox.delete(index)
+            del self.files[index]
+        self.text_widget.delete(1.0, tk.END)
+
+    def remove_all(self):
+        self.listbox.delete(0, tk.END)
+        self.files.clear()
+        self.text_widget.delete(1.0, tk.END)
+
+    def start_parser(self):
+        if not self.files:
+            messagebox.showinfo("No Files", "Please select at least one file.")
+            return
+        self.progress_text.config(state=tk.NORMAL)
+        self.progress_text.delete(1.0, tk.END)
+        self.progress_text.insert(tk.END, "Starting parser...\n")
+        self.progress_text.config(state=tk.DISABLED)
+        thread = threading.Thread(target=self.run_parser)
+        thread.start()
+
+    def stop_parser(self):
+        if self.parser_process and self.parser_process.poll() is None:
+            self.parser_process.terminate()
+            self.append_progress_text("Parser process was stopped.\n")
+        else:
+            self.append_progress_text("No active parser process to stop.\n")
+
+    def run_parser(self):
+        try:
+            self.parser_process = subprocess.Popen(
+                [sys.executable, __file__] + self.files,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                encoding='utf-8',
+                errors='ignore',
+                bufsize=4096
+            )
+            for line in self.parser_process.stdout:
+                self.append_progress_text(line)
+            self.parser_process.stdout.close()
+            self.parser_process.wait()
+
+            if self.parser_process.returncode == 0:
+                self.append_progress_text("\nParser finished successfully.\n")
+                self.show_messagebox_threadsafe("Parser Done", "The parser was executed successfully.")
+            else:
+                self.append_progress_text("\nError while running the parser.\n")
+                self.show_messagebox_threadsafe("Error", "Error while running the parser.")
+        except Exception as e:
+            self.append_progress_text(f"Error: {e}\n")
+            self.show_messagebox_threadsafe("Error", f"Error during execution:\n{e}")
+        finally:
+            self.parser_process = None
+
+    def append_progress_text(self, text):
+        self.progress_text.after(0, lambda: self._insert_text(text))
+
+    def _insert_text(self, text):
+        self.progress_text.config(state=tk.NORMAL)
+        self.progress_text.insert(tk.END, text)
+        self.progress_text.see(tk.END)
+        self.progress_text.config(state=tk.DISABLED)
+
+    def show_messagebox_threadsafe(self, title, message):
+        self.master.after(0, lambda: messagebox.showinfo(title, message))
+
+    def show_text_file(self, event):
+        selection = self.listbox.curselection()
+        if not selection:
+            return
+        index = selection[0]
+        path = self.files[index]
+        txt_path = os.path.splitext(path)[0] + ".txt"
+        self.text_widget.delete(1.0, tk.END)
+        if os.path.exists(txt_path):
+            try:
+                with open(txt_path, "r", encoding="utf-8", errors="ignore") as f:
+                    self.text_widget.insert(tk.END, f.read())
+            except Exception as e:
+                self.text_widget.insert(tk.END, f"Error loading text file:\n{e}")
+        else:
+            self.text_widget.insert(tk.END, "[No corresponding .txt file found]")
+
+# ========================
+# Entry Point
+# ========================
+
+if __name__ == "__main__":
+    multiprocessing.freeze_support()  # Must be first in main for compatibility with multiprocessing on Windows
+
+    if len(sys.argv) > 1:
+        process_pdfs_main()
+    else:
+        root = tk.Tk()
+        app = FileManager(root)
+        root.mainloop()
+