PyMuPDF failt

[Nikopre]

Description of the bug

Following: (macOS Sequoia Beta/RC?, M-Chip, Python 3.12 via official installer, PyMuPDF Version), den ModuleNotFoundError oder AttributeError und die Tatsache, dass fitz.doc None ist.

--- Minimaler PyMuPDF Test ---
Python Executable: /Applications/pdf_schwärzer_venv/bin/python
Python Version: 3.12.10
Plattform: Darwin 24.4.0
Ein Fehler ist aufgetreten: 'NoneType' object has no attribute 'split'
--- Test Ende ---

Havy anyone a answer?

How to reproduce the bug

--- Minimaler PyMuPDF Test ---
Python Executable: /Applications/pdf_schwärzer_venv/bin/python
Python Version: 3.12.10
Plattform: Darwin 24.4.0
Ein Fehler ist aufgetreten: 'NoneType' object has no attribute 'split'
--- Test Ende ---

PyMuPDF version

1.25.5

Operating system

MacOS

Python version

3.12

[JorjMcKie]

Sorry, we cannot deal with bug submissions where all mandatory data are missing. We need a script and a reproducing file.

[Nikopre]

Sorry, here ist the code:

import tkinter as tk
from tkinter import filedialog, messagebox, simpledialog
from PIL import Image, ImageTk
import fitz # PyMuPDF / fitz
import os
import sys
import json
import platform # Für detailliertere Systeminfos

--- Globale Konstanten ---

APP_TITLE = "PDF Schwärzer Pro v2 (Robust)"
WINDOW_GEOMETRY = "950x750"
DISPLAY_SCALE = 1.5
MOUSE_WHEEL_SCROLL_STEP = 2
REDACTION_FILL_COLOR = (0.0, 0.0, 0.0) # Schwarz
TEMPLATE_FILE_EXTENSION = ".json"
TEMPLATE_FILE_DESC = "Schwärzungs-Vorlage"

------------------------------------------------------------------------------

Funktion zur Überprüfung der Umgebung (Wird sofort beim Start ausgeführt)

------------------------------------------------------------------------------

def check_environment():
"""Gibt wichtige Umgebungsinformationen im Terminal aus."""
print("--- PDF Schwärzer - Umgebungs-Check ---")
print(f"Plattform: {platform.system()} {platform.release()} ({platform.machine()})")
print(f"Python Ausführbar: {sys.executable}")
print(f"Python Version: {sys.version.split()[0]} ({platform.python_implementation()})")
print(f"Akt. Arbeitsverz.: {os.getcwd()}")
try:
print(f"PyMuPDF (fitz) Pfad: {fitz.file}")
# Version steht oft im Docstring des Moduls
fitz_version = getattr(fitz, 'version', None) or getattr(fitz, 'version', None) or fitz.doc.split()[1]
print(f"PyMuPDF (fitz) Ver.: {fitz_version}")
# *** Kritischer Test: Hat das Modul die Funktion? ***
doc = None
try:
# Versuche, ein leeres Dokument zu erstellen und die Methode zu prüfen
doc = fitz.open() # Leeres Dokument
has_apply = hasattr(doc, 'apply_redactions')
print(f"Check: 'apply_redactions' Methode vorhanden? -> {has_apply}")
if not has_apply:
print("\n*** WARNUNG: 'apply_redactions' wurde nicht im PyMuPDF-Objekt gefunden! ")
print(" Schwärzen wird wahrscheinlich fehlschlagen. Bitte PyMuPDF prüfen/neu installieren! ***\n")
except Exception as check_err:
print(f"Fehler beim Prüfen von apply_redactions: {check_err}")
finally:
if doc: doc.close()

except Exception as e:
    print(f"!! FEHLER beim Ermitteln der PyMuPDF-Details: {e} !!")
    print("!! Stellen Sie sicher, dass PyMuPDF korrekt installiert ist ('pip install pymupdf'). !!")
print("------------------------------------------")
# Kurze Pause, damit man die Ausgabe im Terminal sehen kann, falls es direkt wieder schließt
# import time
# time.sleep(2)

------------------------------------------------------------------------------

Hauptanwendungsklasse

------------------------------------------------------------------------------

class PDFRedactorApp:
"""Hauptklasse für die PDF-Schwärzungsanwendung."""

def __init__(self, master):
    self.master = master
    self.master.title(APP_TITLE)
    self.master.geometry(WINDOW_GEOMETRY)

    # --- Anwendungszustand ---
    self.pdf_document = None          # Aktuelles fitz.Document Objekt
    self.current_pdf_path = None      # Pfad zur aktuell geladenen PDF
    self.current_page_num = 0         # Aktuell angezeigte Seitennummer (0-basiert)
    self.total_pages = 0              # Gesamtseitenzahl
    self.redactions = {}              # Dict: { "seitennr_str": [[x0,y0,x1,y1], ...], ... }
    self.current_page_tk_image = None # Referenz auf das angezeigte Tkinter-Bild
    self.selection_start_coords = None# Start (x, y) für Rechteckauswahl (Canvas-Koordinaten)
    self.selection_rect_id = None     # ID des temporären Auswahlrechtecks auf dem Canvas

    # --- GUI Erstellen ---
    self._create_widgets()
    self._bind_events()
    self.update_status("Bereit. Bitte PDF laden.")
    self.update_ui_controls_state() # Initialen Zustand der Buttons setzen

# --- GUI Aufbau ---
def _create_widgets(self):
    """Erstellt die grafischen Elemente (Widgets)."""
    # Top Frame (Buttons etc.)
    top_frame = tk.Frame(self.master, padx=5, pady=5)
    top_frame.pack(fill=tk.X)

    self.btn_load = tk.Button(top_frame, text="PDF Laden", command=self.load_pdf)
    self.btn_load.pack(side=tk.LEFT, padx=(0, 10))

    self.lbl_page_info = tk.Label(top_frame, text="Seite: -/-", width=12, anchor='w')
    self.lbl_page_info.pack(side=tk.LEFT, padx=5)

    self.btn_prev = tk.Button(top_frame, text="<<", command=self.prev_page)
    self.btn_prev.pack(side=tk.LEFT)
    self.btn_next = tk.Button(top_frame, text=">>", command=self.next_page)
    self.btn_next.pack(side=tk.LEFT, padx=(2, 10))

    self.btn_goto = tk.Button(top_frame, text="Gehe zu...", command=self.goto_page)
    self.btn_goto.pack(side=tk.LEFT, padx=5)

    # Rechte Seite für Aktionen
    action_frame = tk.Frame(top_frame)
    action_frame.pack(side=tk.RIGHT)

    self.btn_save = tk.Button(action_frame, text="Schwärzen & Speichern", command=self.apply_and_save)
    self.btn_save.pack(side=tk.RIGHT, padx=(5, 0))
    self.btn_load_template = tk.Button(action_frame, text="Vorlage laden", command=self.load_template)
    self.btn_load_template.pack(side=tk.RIGHT, padx=5)
    self.btn_save_template = tk.Button(action_frame, text="Vorlage speichern", command=self.save_template)
    self.btn_save_template.pack(side=tk.RIGHT, padx=5)
    self.btn_clear = tk.Button(action_frame, text="Auswahl löschen", command=self.clear_redactions)
    self.btn_clear.pack(side=tk.RIGHT, padx=5)


    # Canvas Frame mit Scrollbars
    canvas_frame = tk.Frame(self.master, bd=2, relief=tk.SUNKEN)
    canvas_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

    v_scroll = tk.Scrollbar(canvas_frame, orient=tk.VERTICAL)
    h_scroll = tk.Scrollbar(canvas_frame, orient=tk.HORIZONTAL)
    self.canvas = tk.Canvas(canvas_frame, bg="lightgrey",
                             yscrollcommand=v_scroll.set, xscrollcommand=h_scroll.set)
    v_scroll.config(command=self.canvas.yview)
    h_scroll.config(command=self.canvas.xview)

    v_scroll.pack(side=tk.RIGHT, fill=tk.Y)
    h_scroll.pack(side=tk.BOTTOM, fill=tk.X)
    self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

    # Status Bar
    self.status_bar = tk.Label(self.master, text="", bd=1, relief=tk.SUNKEN, anchor=tk.W)
    self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)

# --- Event Binding ---
def _bind_events(self):
    """Bindet Ereignisse an Handler-Methoden."""
    self.canvas.bind("<ButtonPress-1>", self.on_mouse_press)
    self.canvas.bind("<B1-Motion>", self.on_mouse_drag)
    self.canvas.bind("<ButtonRelease-1>", self.on_mouse_release)
    self.master.protocol("WM_DELETE_WINDOW", self.on_close)

    # Mausrad-Binding (plattformabhängig)
    if platform.system() == "Linux":
        self.canvas.bind("<Button-4>", self.on_mouse_wheel) # Hoch
        self.canvas.bind("<Button-5>", self.on_mouse_wheel) # Runter
    else: # macOS, Windows
        self.canvas.bind("<MouseWheel>", self.on_mouse_wheel)

# --- Kernlogik: PDF Laden & Anzeigen ---
def load_pdf(self):
    """Öffnet eine PDF-Datei, zeigt erste Seite an."""
    filepath = filedialog.askopenfilename(
        title="PDF auswählen", filetypes=[("PDF Dateien", "*.pdf")], parent=self.master)
    if not filepath: return # Abbruch

    self.update_status("Lade PDF...")
    self.master.update_idletasks()
    self.close_current_pdf() # Vorheriges Dokument schließen
    self.redactions = {}     # Alte Schwärzungen löschen

    try:
        self.current_pdf_path = filepath
        doc = fitz.open(filepath)

        # Passwortabfrage, falls nötig
        if doc.needs_pass:
            pw = simpledialog.askstring("Passwort", f"Passwort für '{os.path.basename(filepath)}':",
                                         show='*', parent=self.master)
            if not pw or doc.authenticate(pw) == 0:
                raise ValueError("Falsches Passwort oder Abbruch.")

        self.pdf_document = doc
        self.total_pages = len(doc)
        if self.total_pages == 0:
             raise ValueError("Leeres PDF (keine Seiten).")
        self.current_page_num = 0
        self.display_page(self.current_page_num)
        self.update_status(f"'{os.path.basename(filepath)}' geladen ({self.total_pages} Seiten)")

    except Exception as e:
        messagebox.showerror("Ladefehler", f"Fehler beim Laden der PDF:\n{e}", parent=self.master)
        self.close_current_pdf() # Sicherstellen, dass geschlossen wird
        self.reset_ui_state()
    finally:
        self.update_ui_controls_state()

def display_page(self, page_num):
    """Zeigt die angegebene Seite (0-basiert) an."""
    if not self.pdf_document or not (0 <= page_num < self.total_pages): return

    self.current_page_num = page_num
    self.update_status(f"Rendere Seite {page_num + 1}...")
    self.master.update_idletasks()

    try:
        page = self.pdf_document.load_page(page_num)
        mat = fitz.Matrix(DISPLAY_SCALE, DISPLAY_SCALE)
        pix = page.get_pixmap(matrix=mat, alpha=False)
        img = Image.frombytes("RGB", (pix.width, pix.height), pix.samples)

        # Alte Bildreferenz löschen (wichtig!)
        if self.current_page_tk_image: del self.current_page_tk_image

        self.current_page_tk_image = ImageTk.PhotoImage(img)

        # Canvas aktualisieren
        self.canvas.delete("all")
        self.canvas.config(scrollregion=(0, 0, pix.width, pix.height))
        self.canvas.create_image(0, 0, anchor="nw", image=self.current_page_tk_image, tags="page")
        self._draw_redactions_on_canvas() # Schwärzungen für diese Seite zeichnen

        self.lbl_page_info.config(text=f"Seite: {page_num + 1}/{self.total_pages}")
        self.update_status(f"Seite {page_num + 1} angezeigt.")

    except Exception as e:
        messagebox.showerror("Anzeigefehler", f"Fehler beim Anzeigen von Seite {page_num + 1}:\n{e}", parent=self.master)
        self.update_status(f"Anzeigefehler Seite {page_num + 1}")
    finally:
         self.update_ui_controls_state()

def _draw_redactions_on_canvas(self):
    """Zeichnet gespeicherte Schwärzungsrechtecke auf den Canvas."""
    page_key = str(self.current_page_num)
    if page_key not in self.redactions: return

    mat = fitz.Matrix(DISPLAY_SCALE, DISPLAY_SCALE)
    for rect_coords in self.redactions[page_key]:
        try:
            rect = fitz.Rect(rect_coords) # Konvertiere Liste zu Rect für Transformation
            tk_rect = rect * mat
            self.canvas.create_rectangle(
                tk_rect.x0, tk_rect.y0, tk_rect.x1, tk_rect.y1,
                fill="black", outline="red", width=1, tags="redaction_visual"
            )
        except Exception as draw_err:
            print(f"Warnung: Fehler beim Zeichnen von Rechteck {rect_coords}: {draw_err}")


# --- Navigation ---
def prev_page(self):
    if self.pdf_document and self.current_page_num > 0:
        self.canvas.yview_moveto(0) # Beim Seitenwechsel nach oben scrollen
        self.canvas.xview_moveto(0)
        self.display_page(self.current_page_num - 1)

def next_page(self):
    if self.pdf_document and self.current_page_num < self.total_pages - 1:
        self.canvas.yview_moveto(0)
        self.canvas.xview_moveto(0)
        self.display_page(self.current_page_num + 1)

def goto_page(self):
    if not self.pdf_document: return
    try:
        page = simpledialog.askinteger("Gehe zu Seite",
                                       f"Seitenzahl (1-{self.total_pages}):",
                                       minvalue=1, maxvalue=self.total_pages,
                                       parent=self.master)
        if page is not None:
            self.canvas.yview_moveto(0)
            self.canvas.xview_moveto(0)
            self.display_page(page - 1) # 0-basiert
    except Exception as e:
        messagebox.showwarning("Eingabe", f"Ungültige Seitenzahl.\n{e}", parent=self.master)

# --- Maus-Interaktion für Auswahl ---
def on_mouse_press(self, event):
    """Beginnt das Aufziehen eines Rechtecks."""
    if not self.pdf_document: return
    self.canvas.focus_set()
    self.selection_start_coords = (self.canvas.canvasx(event.x), self.canvas.canvasy(event.y))
    if self.selection_rect_id: self.canvas.delete(self.selection_rect_id)
    self.selection_rect_id = None

def on_mouse_drag(self, event):
    """Zeichnet/aktualisiert das temporäre Auswahlrechteck."""
    if not self.selection_start_coords: return
    x0, y0 = self.selection_start_coords
    x1 = self.canvas.canvasx(event.x)
    y1 = self.canvas.canvasy(event.y)
    if self.selection_rect_id:
        self.canvas.coords(self.selection_rect_id, x0, y0, x1, y1)
    else:
        self.selection_rect_id = self.canvas.create_rectangle(
            x0, y0, x1, y1, outline="red", width=2, tags="selection_temp"
        )

def on_mouse_release(self, event):
    """Beendet die Auswahl, konvertiert Koordinaten und speichert."""
    if not self.selection_start_coords: return
    x0, y0 = self.selection_start_coords
    x1 = self.canvas.canvasx(event.x)
    y1 = self.canvas.canvasy(event.y)
    if self.selection_rect_id: self.canvas.delete(self.selection_rect_id)
    self.selection_rect_id = None
    self.selection_start_coords = None

    # Normalisiere Rechteckkoordinaten (x0<x1, y0<y1)
    cx0, cx1 = min(x0, x1), max(x0, x1)
    cy0, cy1 = min(y0, y1), max(y0, y1)

    if abs(cx1 - cx0) < 3 or abs(cy1 - cy0) < 3: return # Zu klein

    try:
        pdf_rect = self._convert_canvas_to_pdf_rect(cx0, cy0, cx1, cy1)
        if pdf_rect:
            page_key = str(self.current_page_num)
            if page_key not in self.redactions: self.redactions[page_key] = []

            # Nur hinzufügen, wenn noch nicht vorhanden (als Liste von Floats)
            rect_coords = list(pdf_rect) # [x0, y0, x1, y1]
            if rect_coords not in self.redactions[page_key]:
                self.redactions[page_key].append(rect_coords)
                self._draw_redactions_on_canvas() # Neu zeichnen
                self.update_status(f"Bereich auf Seite {self.current_page_num + 1} hinzugefügt.")
                self.update_ui_controls_state()
            else:
                 self.update_status(f"Bereich bereits vorhanden.")

    except Exception as e:
         messagebox.showerror("Koordinatenfehler", f"Fehler bei Koordinatenumrechnung:\n{e}", parent=self.master)
         self.update_status("Fehler bei Bereichsdefinition.")


def _convert_canvas_to_pdf_rect(self, cx0, cy0, cx1, cy1):
    """Konvertiert Canvas-Rechteckkoordinaten in PDF-Koordinaten (fitz.Rect)."""
    if not self.pdf_document: return None
    page = self.pdf_document.load_page(self.current_page_num)
    mat = fitz.Matrix(DISPLAY_SCALE, DISPLAY_SCALE)
    inv_mat = ~mat # Inverse Matrix
    p1 = fitz.Point(cx0, cy0) * inv_mat
    p2 = fitz.Point(cx1, cy1) * inv_mat
    pdf_rect = fitz.Rect(p1, p2).normalize()
    # Auf Seitengröße beschneiden
    pdf_rect &= page.rect
    if pdf_rect.is_empty or pdf_rect.width < 1 or pdf_rect.height < 1:
        return None
    return pdf_rect

def on_mouse_wheel(self, event):
    """Scrollt den Canvas vertikal."""
    if platform.system() == "Linux":
        delta = -1 if event.num == 4 else (1 if event.num == 5 else 0)
    elif platform.system() == "Darwin": # macOS
         delta = event.delta
    else: # Windows
        delta = -1 if event.delta < 0 else 1

    if delta != 0:
        scroll_amount = MOUSE_WHEEL_SCROLL_STEP if delta > 0 else -MOUSE_WHEEL_SCROLL_STEP
        # Korrigiere die Logik basierend auf delta's Vorzeichen auf Windows/Mac
        if platform.system() != "Linux":
             scroll_amount = -scroll_amount if delta < 0 else scroll_amount

        self.canvas.yview_scroll(int(scroll_amount), "units")


# --- Vorlagen-Handling ---
def save_template(self):
    """Speichert die aktuellen Schwärzungsbereiche als JSON-Vorlage."""
    if not self.redactions:
         messagebox.showwarning("Keine Auswahl", "Nichts zum Speichern.", parent=self.master)
         return

    fpath = filedialog.asksaveasfilename(
        title="Vorlage speichern", defaultextension=TEMPLATE_FILE_EXTENSION,
        filetypes=[(TEMPLATE_FILE_DESC, f"*{TEMPLATE_FILE_EXTENSION}")], parent=self.master)
    if not fpath: return

    try:
        with open(fpath, 'w', encoding='utf-8') as f:
            json.dump(self.redactions, f, indent=2) # Speichere das Dictionary direkt
        self.update_status(f"Vorlage '{os.path.basename(fpath)}' gespeichert.")
        messagebox.showinfo("Gespeichert", "Vorlage erfolgreich gespeichert.", parent=self.master)
    except Exception as e:
        messagebox.showerror("Speicherfehler", f"Vorlage konnte nicht gespeichert werden:\n{e}", parent=self.master)

def load_template(self):
    """Lädt Schwärzungsbereiche aus einer JSON-Vorlage."""
    fpath = filedialog.askopenfilename(
        title="Vorlage laden", filetypes=[(TEMPLATE_FILE_DESC, f"*{TEMPLATE_FILE_EXTENSION}")], parent=self.master)
    if not fpath: return

    try:
        with open(fpath, 'r', encoding='utf-8') as f:
            loaded_data = json.load(f)

        # Einfache Validierung
        if not isinstance(loaded_data, dict): raise TypeError("Kein Dictionary")
        for k, v in loaded_data.items():
            if not isinstance(v, list): raise TypeError(f"Wert für Seite {k} ist keine Liste")
            for item in v:
                 if not (isinstance(item, list) and len(item) == 4):
                     raise TypeError(f"Ungültiges Rechteckformat in Seite {k}: {item}")

        self.redactions = loaded_data # Überschreibe aktuelle Auswahl
        self.update_status(f"Vorlage '{os.path.basename(fpath)}' geladen.")
        if self.pdf_document:
            self.display_page(self.current_page_num) # Neu zeichnen
        self.update_ui_controls_state()

    except Exception as e:
        messagebox.showerror("Ladefehler", f"Fehler beim Laden der Vorlage:\n{e}", parent=self.master)
        self.redactions = {} # Bei Fehler sicherheitshalber leeren
        self.update_ui_controls_state()


def clear_redactions(self):
    """Entfernt alle aktuellen Schwärzungsbereiche."""
    if not self.redactions: return
    if messagebox.askyesno("Löschen", "Alle Schwärzungsbereiche entfernen?", icon='question', parent=self.master):
        self.redactions = {}
        self.canvas.delete("redaction_visual") # Nur Markierungen entfernen
        self.update_status("Auswahl gelöscht.")
        self.update_ui_controls_state()

# --- Schwärzen & Speichern (Der kritische Teil!) ---
def apply_and_save(self):
    """Wendet Schwärzungen an und speichert als neue PDF."""
    if not self.pdf_document:
         messagebox.showwarning("Kein PDF", "Kein PDF geladen.", parent=self.master)
         return
    if not self.redactions:
         messagebox.showwarning("Keine Auswahl", "Keine Bereiche zum Schwärzen definiert.", parent=self.master)
         return

    # === WARNUNG ===
    if not messagebox.askyesno("Bestätigen",
                               "ACHTUNG!\nDie Bereiche werden unwiderruflich entfernt.\nFORTFAHREN?",
                               icon='warning', parent=self.master):
        self.update_status("Speichern abgebrochen.")
        return

    # === Speicherort wählen ===
    save_path = filedialog.asksaveasfilename(
        title="Geschwärzte PDF speichern",
        initialfile=f"{os.path.splitext(os.path.basename(self.current_pdf_path))[0]}_geschwaerzt.pdf",
        defaultextension=".pdf", filetypes=[("PDF Dateien", "*.pdf")], parent=self.master)
    if not save_path:
         self.update_status("Speichern abgebrochen.")
         return
    if os.path.abspath(save_path) == os.path.abspath(self.current_pdf_path):
        messagebox.showerror("Fehler", "Überschreiben der Originaldatei nicht erlaubt.", parent=self.master)
        return

    # === Verarbeitung ===
    self.update_status("Wende Schwärzungen an...")
    self.master.config(cursor="watch")
    self.master.update_idletasks()

    doc_to_save = None # Wichtig für finally
    success = False
    try:
        # Originaldatei *neu* öffnen, um das Original im Speicher nicht zu ändern
        doc_to_save = fitz.open(self.current_pdf_path)
        if doc_to_save.needs_pass:
             pw = simpledialog.askstring("Passwort", f"Passwort für '{os.path.basename(self.current_pdf_path)}' (erneut):", show='*', parent=self.master)
             if not pw or doc_to_save.authenticate(pw) == 0:
                  raise ValueError("Falsches Passwort oder Abbruch beim Speichern.")

        redactions_applied_count = 0
        # Schwärzungs-Annotationen hinzufügen
        for page_num_str, rect_list in self.redactions.items():
             try:
                 page_num = int(page_num_str)
                 if 0 <= page_num < len(doc_to_save):
                     page = doc_to_save.load_page(page_num)
                     for rect_coords in rect_list:
                         # Stelle sicher, dass es ein gültiges Rect ist
                         try:
                             rect = fitz.Rect(rect_coords)
                             if not rect.is_empty:
                                  annot = page.add_redact_annot(rect, fill=REDACTION_FILL_COLOR)
                                  if annot: redactions_applied_count += 1
                         except ValueError:
                              print(f"Warnung: Ungültige Koordinaten übersprungen: {rect_coords}")
             except ValueError:
                  print(f"Warnung: Ungültiger Seitenschlüssel übersprungen: {page_num_str}")

        if redactions_applied_count == 0:
             messagebox.showwarning("Nichts zu tun", "Keine gültigen Schwärzungsbereiche gefunden.", parent=self.master)
             self.update_status("Keine gültigen Schwärzungen angewendet.")
             # Verlasse try-Block, finally wird ausgeführt
             return # Verhindert Speichern einer leeren Datei

        # === Hier ist der entscheidende Aufruf! ===
        try:
            print(f"INFO: Rufe apply_redactions für Dokument vom Typ {type(doc_to_save)} auf...")
            doc_to_save.apply_redactions(images=fitz.PDF_REDACT_IMAGE_PIXELS)
            print("INFO: apply_redactions erfolgreich ausgeführt.")
        except AttributeError as ae:
             # Den spezifischen Fehler erneut abfangen und anzeigen
             print(f"!!! FATALER FEHLER: {ae} !!!")
             messagebox.showerror("Kritischer Fehler",
                                  f"Die Methode 'apply_redactions' fehlt!\n"
                                  f"({ae})\n\n"
                                  f"Bitte PyMuPDF-Installation prüfen (siehe Terminal-Ausgabe beim Start).",
                                  parent=self.master)
             # Verlasse try-Block, finally wird ausgeführt
             return
        except Exception as apply_err:
             # Andere Fehler beim Anwenden abfangen
             print(f"Fehler während apply_redactions: {apply_err}")
             raise apply_err # Erneut auslösen, um im äußeren except behandelt zu werden


        # Speichern mit Optimierung
        doc_to_save.save(save_path, garbage=4, deflate=True, clean=True)
        success = True

    except Exception as e:
        messagebox.showerror("Speicherfehler", f"Fehler beim Verarbeiten oder Speichern:\n{e}", parent=self.master)
        self.update_status(f"Fehler beim Speichern: {e}")
    finally:
        if doc_to_save: doc_to_save.close() # Temporäres Dokument immer schließen
        self.master.config(cursor="")      # Cursor zurücksetzen
        if success:
             messagebox.showinfo("Erfolg", f"Geschwärzte PDF gespeichert:\n{save_path}", parent=self.master)
             self.update_status("Speichern erfolgreich.")
             # Nach Erfolg: Schließe Original und setze UI zurück
             self.close_current_pdf()
             self.reset_ui_state()
        # Bei Misserfolg bleibt das Originaldokument geladen


# --- Hilfsfunktionen ---
def update_status(self, text):
    """Aktualisiert die Statusleiste."""
    self.status_bar.config(text=str(text))

def update_ui_controls_state(self):
    """(De-)Aktiviert Buttons basierend auf dem Zustand."""
    has_doc = self.pdf_document is not None
    has_redactions = bool(self.redactions)

    # Navigation
    self.btn_prev.config(state=tk.NORMAL if has_doc and self.current_page_num > 0 else tk.DISABLED)
    self.btn_next.config(state=tk.NORMAL if has_doc and self.current_page_num < self.total_pages - 1 else tk.DISABLED)
    self.btn_goto.config(state=tk.NORMAL if has_doc else tk.DISABLED)

    # Aktionen
    self.btn_save_template.config(state=tk.NORMAL if has_redactions else tk.DISABLED)
    self.btn_load_template.config(state=tk.NORMAL if has_doc else tk.DISABLED) # Laden immer möglich, wenn Doc da
    self.btn_clear.config(state=tk.NORMAL if has_redactions else tk.DISABLED)
    self.btn_save.config(state=tk.NORMAL if has_doc and has_redactions else tk.DISABLED)

def close_current_pdf(self):
    """Schließt das aktuelle PDF-Dokument sicher."""
    if self.pdf_document:
        try:
            self.pdf_document.close()
        except Exception: pass # Fehler beim Schließen ignorieren
    self.pdf_document = None
    self.current_pdf_path = None
    self.total_pages = 0
    self.current_page_num = 0
    if self.current_page_tk_image: del self.current_page_tk_image # Referenz löschen
    self.current_page_tk_image = None

def reset_ui_state(self):
    """Setzt die UI und den internen Zustand zurück."""
    self.close_current_pdf()
    self.redactions = {}
    self.canvas.delete("all")
    self.canvas.config(scrollregion=(0,0,1,1))
    self.lbl_page_info.config(text="Seite: -/-")
    self.update_status("Bereit. Bitte PDF laden.")
    self.update_ui_controls_state()

def on_close(self):
    """Wird beim Schließen des Fensters aufgerufen."""
    # Optional: Nachfrage, ob wirklich geschlossen werden soll
    self.update_status("Beende...")
    self.close_current_pdf()
    self.master.destroy()

--- Hauptausführung ---

if name == "main":
# Führe den Umgebungs-Check vor dem Start der GUI aus
check_environment()

# Erstelle das Hauptfenster und die Anwendung
root = tk.Tk()
app = PDFRedactorApp(root)

# Starte die Tkinter Ereignisschleife
root.mainloop()

an her is the Message from Terminal:

Last login: Tue Apr 22 16:33:25 on ttys000
cd '/Applications/' && '/usr/local/bin/python3.12' '/Applications/PDF black_nav1.py' && echo Exit status: $? && exit 1
nik@MacBookAir ~ % cd '/Applications/' && '/usr/local/bin/python3.12' '/Applications/PDF black_nav1.py' && echo Exit status: $? && exit 1
Traceback (most recent call last):
File "/Applications/PDF black_nav1.py", line 3, in
from PIL import Image, ImageTk
ModuleNotFoundError: No module named 'PIL'

[JorjMcKie]

This is obviously not a PyMuPDF problem. You have not installed PIL / Pillow.

[Nikopre]

This is obviously not a PyMuPDF problem. You have not installed PIL / Pillow.

Thank you, I will see if I can fix the error thanks to your advice

[Nikopre]

I have installed the PIL / Pillow..but that did not solve the problem... Last login: Tue Apr 22 19:15:10 on ttys001
nikopreus@34059a29-b1cf-4210-9f7b-3e3aa85269d2 ~ % cd /Applications/
nikopreus@34059a29-b1cf-4210-9f7b-3e3aa85269d2 /Applications % source pdf_schwärzer_venv/bin/activate
((pdf_schwärzer_venv) ) nikopreus@34059a29-b1cf-4210-9f7b-3e3aa85269d2 /Applications % python "PDF black_nav1.py"
--- PDF Schwärzer - Umgebungs-Check ---
Plattform: Darwin 24.4.0 (arm64)
Python Ausführbar: /Applications/pdf_schwärzer_venv/bin/python
Python Version: 3.12.10 (CPython)
Akt. Arbeitsverz.: /Applications
PyMuPDF (fitz) Pfad: /Applications/pdf_schwärzer_venv/lib/python3.12/site-packages/fitz/init.py
PyMuPDF (fitz) Ver.: ('1.24.7', '1.24.4', '20240626000001')
Check: 'apply_redactions' Methode vorhanden? -> False

*** WARNUNG: 'apply_redactions' wurde nicht im PyMuPDF-Objekt gefunden! ***
*** Schwärzen wird wahrscheinlich fehlschlagen. Bitte PyMuPDF prüfen/neu installieren! ***

---

2025-04-22 19:18:33.172 Python[46999:4765965] The class 'NSOpenPanel' overrides the method identifier. This method is implemented by class 'NSWindow'
2025-04-22 19:18:57.136 Python[46999:4765965] The class 'NSSavePanel' overrides the method identifier. This method is implemented by class 'NSWindow'
INFO: Rufe apply_redactions für Dokument vom Typ <class 'pymupdf.Document'> auf...
!!! FATALER FEHLER: 'Document' object has no attribute 'apply_redactions' !!!

[JorjMcKie]

I am realizing that you do not post a bug issue here, but that you are seeking help. Transferring this to the Discussions tab.

[JorjMcKie]

Reacting to your new (!) problem:
Please consult the documentation: a Document has no .apply_redactions(), only a Page object has that.