Error upon reopening window with image: _tkinter.TclError: image "pyimage2" doesn't exist

[BhagyaJyoti22006]

My code:-

import customtkinter as ctk
import asyncio
from PIL import Image

class Info:
    refresh = False

class App(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.geometry("200x300")
        self.protocol("WM_DELETE_WINDOW", self.close)
        self.button = ctk.CTkButton(self, command=self.refresh)
        self.button.grid(row=0,column=0)
        self.image= Image.open("example.png") # your different image file name
        self.image_ctk = ctk.CTkImage(light_image=self.image, dark_image=self.image, size=(32, 32))
        self.button2 = ctk.CTkButton(self, image=self.image_ctk)
        self.button2.grid(row=0,column=1)
        
    def refresh(self):
        Info.refresh = True
        self.withdraw()
        self.quit()
        pass
    def close(self):
        self.withdraw()
        self.quit()
        pass

async def main():
    while True:
        root = App()
        root.mainloop()
        if Info.refresh is False:
            root.destroy()
            break
        Info.refresh = False
        # await function
    pass

if __name__ == "__main__":
    asyncio.run(main())

I have a button which when clicked with close window. Then, I perform some await tasks. Then, I rerun the window.
If I have no images in my code, no error occurs. But, if I add images, like self.button2 referncing one. Then, I get following error upon reopening:-

self.tk.call(_flatten((self._w, cmd)) + self._options(cnf))
_tkinter.TclError: image "pyimage2" doesn't exist

I have hit a dead end and don't know where to go.

[Anonymous6598]

Had same error. Solution will be soon.

[Anonymous6598]

here is solution from stackoverflow: https://stackoverflow.com/questions/26097811/image-pyimage2-doesnt-exist

[BhagyaJyoti22006]

here is solution from stackoverflow: https://stackoverflow.com/questions/26097811/image-pyimage2-doesnt-exist

The working solution was adding master parameter in tk.PhotoImage. But, customtkinter has no parameter as such. I tried putting a tkinter image and it worked. But ctk raised same error.

[Anonymous6598]

here is solution from stackoverflow: https://stackoverflow.com/questions/26097811/image-pyimage2-doesnt-exist

The working solution was adding master parameter in tk.PhotoImage. But, customtkinter has no parameter as such. I tried putting a tkinter image and it worked. But ctk raised same error.

understood

[Anonymous6598]

we have to change ctk.CTk() to ctk.CTkTopLevel()

[Anonymous6598]

It's not only ones. It reopens as a loop.

[Anonymous6598]

But he reopening happens only once. I want a loop. Clicking on the button for second time creates a duplicate window without closing previous top level window.

Also, without image, two ctk worked. Only image is causing problem somehow.

The issue was in Image. Because we destroyed the main CTk, the interpreter raised an exception that the key doesn't exist. That's why.

[BhagyaJyoti22006]

But he reopening happens only once. I want a loop. Clicking on the button for second time creates a duplicate window without closing previous top level window.
Also, without image, two ctk worked. Only image is causing problem somehow.

The issue was in Image. Because we destroyed the main CTk, the interpreter raised an exception that the key doesn't exist. That's why.

oho. and since we defined that thing with master. it got destroyed with master. thanks for explaining bro.

[Anonymous6598]

Yep

[Anonymous6598]

You fixed the issue. @BhagyaJyoti22006, you did it. I didn't do anything.

[BhagyaJyoti22006]

I edited ctkimage.py in the customtkinter/windows/widgets/images and added master parameter for PhotoImage object.
This solved the problem for forever.

from typing import Tuple, Dict, Callable, List
try:
    from PIL import Image, ImageTk
except ImportError:
    pass


class CTkImage:
    """
    Class to store one or two PIl.Image.Image objects and display size independent of scaling:

    light_image: PIL.Image.Image for light mode
    dark_image: PIL.Image.Image for dark mode
    size: tuple (<width>, <height>) with display size for both images

    One of the two images can be None and will be replaced by the other image.
    """

    _checked_PIL_import = False

    def __init__(self, master=None,
                 light_image: "Image.Image" = None,
                 dark_image: "Image.Image" = None,
                 size: Tuple[int, int] = (20, 20)):

        if not self._checked_PIL_import:
            self._check_pil_import()

        self.master = master
        self._light_image = light_image
        self._dark_image = dark_image
        self._check_images()
        self._size = size
        
        self._configure_callback_list: List[Callable] = []
        self._scaled_light_photo_images: Dict[Tuple[int, int], ImageTk.PhotoImage] = {}
        self._scaled_dark_photo_images: Dict[Tuple[int, int], ImageTk.PhotoImage] = {}

    @classmethod
    def _check_pil_import(cls):
        try:
            _, _ = Image, ImageTk
        except NameError:
            raise ImportError("PIL.Image and PIL.ImageTk couldn't be imported")

    def add_configure_callback(self, callback: Callable):
        """ add function, that gets called when image got configured """
        self._configure_callback_list.append(callback)

    def remove_configure_callback(self, callback: Callable):
        """ remove function, that gets called when image got configured """
        self._configure_callback_list.remove(callback)

    def configure(self, **kwargs):
        if "light_image" in kwargs:
            self._light_image = kwargs.pop("light_image")
            self._scaled_light_photo_images = {}
            self._check_images()
        if "dark_image" in kwargs:
            self._dark_image = kwargs.pop("dark_image")
            self._scaled_dark_photo_images = {}
            self._check_images()
        if "size" in kwargs:
            self._size = kwargs.pop("size")

        # call all functions registered with add_configure_callback()
        for callback in self._configure_callback_list:
            callback()

    def cget(self, attribute_name: str) -> any:
        if attribute_name == "light_image":
            return self._light_image
        if attribute_name == "dark_image":
            return self._dark_image
        if attribute_name == "size":
            return self._size

    def _check_images(self):
        # check types
        if self._light_image is not None and not isinstance(self._light_image, Image.Image):
            raise ValueError(f"CTkImage: light_image must be instance if PIL.Image.Image, not {type(self._light_image)}")
        if self._dark_image is not None and not isinstance(self._dark_image, Image.Image):
            raise ValueError(f"CTkImage: dark_image must be instance if PIL.Image.Image, not {type(self._dark_image)}")

        # check values
        if self._light_image is None and self._dark_image is None:
            raise ValueError("CTkImage: No image given, light_image is None and dark_image is None.")

        # check sizes
        if self._light_image is not None and self._dark_image is not None and self._light_image.size != self._dark_image.size:
            raise ValueError(f"CTkImage: light_image size {self._light_image.size} must be the same as dark_image size {self._dark_image.size}.")

    def _get_scaled_size(self, widget_scaling: float) -> Tuple[int, int]:
        return round(self._size[0] * widget_scaling), round(self._size[1] * widget_scaling)

    def _get_scaled_light_photo_image(self, scaled_size: Tuple[int, int]) -> "ImageTk.PhotoImage":
        if scaled_size in self._scaled_light_photo_images:
            return self._scaled_light_photo_images[scaled_size]
        else:
            self._scaled_light_photo_images[scaled_size] = ImageTk.PhotoImage(self._light_image.resize(scaled_size),
                master = self.master)
            return self._scaled_light_photo_images[scaled_size]

    def _get_scaled_dark_photo_image(self, scaled_size: Tuple[int, int]) -> "ImageTk.PhotoImage":
        if scaled_size in self._scaled_dark_photo_images:
            return self._scaled_dark_photo_images[scaled_size]
        else:
            self._scaled_dark_photo_images[scaled_size] = ImageTk.PhotoImage(self._dark_image.resize(scaled_size),
                master = self.master)
            return self._scaled_dark_photo_images[scaled_size]

    def create_scaled_photo_image(self, widget_scaling: float, appearance_mode: str) -> "ImageTk.PhotoImage":
        scaled_size = self._get_scaled_size(widget_scaling)

        if appearance_mode == "light" and self._light_image is not None:
            return self._get_scaled_light_photo_image(scaled_size)
        elif appearance_mode == "light" and self._light_image is None:
            return self._get_scaled_dark_photo_image(scaled_size)

        elif appearance_mode == "dark" and self._dark_image is not None:
            return self._get_scaled_dark_photo_image(scaled_size)
        elif appearance_mode == "dark" and self._dark_image is None:
            return self._get_scaled_light_photo_image(scaled_size)

Search for "master" and you will find 7 instances where code has been edited.

However, this raises the question. I think not adding this parameter must have a definite reason. Is there any other way to do this same thing without changing the main codes?

[Anonymous6598]

You can make pull request to customtkinter repository.

[BhagyaJyoti22006]

You can make pull request to customtkinter repository.

yep. this would be good

[BhagyaJyoti22006]

#2545 created pull request

[Anonymous6598]

If this solved your issue, better don't touch code.