MacOS error with Tkinter code causing segmentation fault (SIGSEGV)

I am working on a Python script that uses the Tkinter Text widget to display text and find hidden characters. When I run my script on MacOS, it crashes with a segmentation fault.

I have narrowed down the issue to the find_and_mark method of the Extension class. Specifically, the crash occurs on this line: self.locations_and_markers[index].place(x=x, y=y, anchor="nw").

The code, when debugging, is shown to tun thrice successfully before crashing. The code runs fine when the place is removed but there's no point to any of the other code without it.

Here is the minimum reproducible example I've been testing with:

from __future__ import annotations

from tkinter import Event, Label
from tkinter import Tk, Text

root = Tk()

text = Text(root)
text.pack(fill="both", expand=True)

# Insert text with hidden characters
text.insert("1.0", "Hello\u00a0 World")

class Marker(Label):
    """A marker for a hidden character"""

    def __init__(self, master: Text) -> None:
        # Make the label
        self.text = master
        super().__init__(master)

    def __repr__(self) -> str:
        return f"Marker-{self._w}"

class Extension:
    """Hidden character finder"""

    def __init__(self, master: Tk) -> None:
        # Set master and mainapp
        self.master = master

        # Set other variables
        self.locations_and_markers: dict[str, Marker] = {}

        # Make binds
        self.master.bind("<Configure>", self.find_and_mark)


    def find_and_mark(self, _: Event | None = None) -> None:
        """Finds all hidden characters and marks them"""

        del _

        # Get the text widget

        # Find all hidden characters
        hidden_char_indexes: list[str] = [text.search(
            "\u00a0", "1.0", "end", regexp=True, nocase=True
        )]

        # Remove all markers
        for marker in self.locations_and_markers.values():
            marker.destroy()
        self.locations_and_markers = {}

        if hidden_char_indexes == [""]:
            return

        # Add markers
        for index in hidden_char_indexes:
            # Create the marker
            self.locations_and_markers[index] = Marker(text)

            # Get the coordinates of the character
            bbox = text.bbox(index)

            # Check that the bbox is not None
            if bbox is None:
                continue

            # Check that the character is visible and in view
            start: str = text.index("@0,0")
            end: str = text.index(f"@{text.winfo_width()},{text.winfo_height()}")
            in_view: bool = text.compare(start, "<=", index) and text.compare(
                index, "<=", end
            )
            if not in_view:
                continue

            # Get the coordinates of the character
            x: int = bbox[0]
            y: int = bbox[1]

            # Place the marker
            self.locations_and_markers[index].place(x=x, y=y, anchor="nw")

Extension(root)

root.mainloop()

Can anyone help me figure out what is causing this segmentation fault and how to fix it? Thank you!

You should be careful when binding a root or top level window. The event handler will be called for events which were reported to child widgets.

So, filter events like this.

...
def find_and_mark(self, e: Event) -> None:
if e.widget != self.master:
return
...

Anyway, the segmentation fault seems to be a bug of Tkinter. In my Linux box, it causes an X11 BadWindow error. What about reporting it here?

Oddly enough, it was simply complaining over no after_idle() in the bind. Adding that fixed it.