Develop Reference

Tkinter doesn't stop execution even after closing the window

In this code I am displaying a window with a label and two buttons, the user can read the file path currently in use in the label and decide if he wants to change it or continue with the buttons.
If he wants to change the path then I change the value inside the textvariable inside the label. The issue is when I do this for example 3 times, then I have to kill the program manually pressing CTRL + C 3 times. If I do it once then I only need to do it once, like there is something preventing the program to terminate. Thanks for the help.
def select_file():
#OPEN TKINTER DIALOG LETTING ME TO CHOOSE A FILE AND RETURNS ITS PATH.
tkinter.Tk().withdraw() # prevents an empty tkinter window from appearing
folder_path = filedialog.askopenfilename()
return folder_path
def change_file():
file_path = select_file()
with open(os.path.expanduser('~/Documents/Squad Generator/excel_file_path.txt'), 'w') as f:
f.write(file_path)
#WRITES THE FILE PATH IN THE VARIABLE AND CHANGES THE LABEL
var.set(file_path)
def homepage():
app.geometry("450x200")
app.title("Squad Generator")
label_1 = tkinter.Label(master=app, justify=tkinter.LEFT,textvariable=var, font =
("JetBrains Mono", 15))
label_1.grid(row=0, column=0, columnspan=2, padx=20, pady=(20, 0), sticky="nsew")
button1 = tkinter.Button(master=app, text="Continua", command=main)
button1.grid(row=1, column=0, padx=20, pady=20, sticky="ew")
#BUTTON CAUSING THE ISSUE.
button2 = tkinter.Button(master=app, command=change_file, text="Cambia file")
button2.grid(row=1, column=1, padx=0, pady=20, sticky="ew")
#CREATING APP MAINLOOP
app.mainloop()
if __name__ == '__main__':
app = tkinter.Tk()
var = tkinter.StringVar(None, check_path_file())
homepage()

I've reorganized your application a bit. I've wrapped everything in a basic class named App which serves as the root of your application. This should work as expected and keep everything contained within a single instance of Tk.
import tkinter
from tkinter.filedialog import askopenfilename
class App(tkinter.Tk): # the App class inherits from Tk
def __init__(self):
super().__init__() # initialize Tk
self.geometry("450x200")
self.title("Squad Generator")
self.label_var=tkinter.StringVar(self, 'Select a file path')
self.label_1 = tkinter.Label(
master=self,
justify=tkinter.LEFT,
textvariable=self.label_var,
font=("JetBrains Mono", 15)
)
self.label_1.grid(row=0, column=0, columnspan=2, padx=20, pady=(20, 0), sticky="nsew")
self.button1 = tkinter.Button(master=self, text="Continua", command=main)
self.button1.grid(row=1, column=0, padx=20, pady=20, sticky="ew")
self.button2 = tkinter.Button(
master=self,
command=self.change_file,
text="Cambia file"
)
self.button2.grid(row=1, column=1, padx=0, pady=20, sticky="ew")
self.change_file() # call this function when the app starts
def change_file(self):
file_path = askopenfilename()
if file_path: # if a file is selected and not cancelled by the user
input_file = '~/Documents/Squad Generator/excel_file_path.txt'
with open(os.path.expanduser(input_file), 'w') as f:
f.write(file_path) # write out 'file_path' to the 'input_file'
#WRITES THE FILE PATH IN THE VARIABLE AND CHANGES THE LABEL
self.label_var.set(file_path)
else:
self.label_var.set('Select a file path') # fallback text if user cancels
if __name__ == '__main__':
app = App() # instantiate your App class
app.mainloop() # run the app
If you're not familiar with classes, the word self here can be confusing. All you need to know is that self refers to the App class. So any widgets you define within that class, like button1 have self as their master - i.e., they are children of the App class!
Also, any methods you define within the class (like change_file(self)) will be callable within the class via self.change_file, and will have access to any variables in the class, like self.label_var!

From what I see you just did
app.destroy()
But you actually need to do
app.master.destroy()
With the first line you're just destroying the current frame, not the the top level container.

The application called an interface that was marshalled for a different thread error

I am writing a code to compare two parts in catia. I used win32com.client to read the document. I am also using threading to run the progress bar. for some reason, I am getting below error even though I have defined document_new as global.
Error:
Exception in thread Thread-22:
Traceback (most recent call last):
File "D:\VirtualEnv\env\lib\threading.py", line 926, in _bootstrap_inner
self.run()
File "D:\VirtualEnv\env\lib\threading.py", line 870, in run
self._target(*self._args, **self._kwargs)
File "C:\Users\as11114\AppData\Local\Temp\ipykernel_16240\2501566542.py", line 62, in STD_Compare
if document_old == document_new:
File "D:\VirtualEnv\env\lib\site-packages\win32com\client\dynamic.py", line 290, in __eq__
return self._oleobj_ == other
pywintypes.com_error: (-2147417842, 'The application called an interface that was marshalled for a different thread.', None, None)
Here is the code. Method STD_Check in class will first read one document and method STD_Compare will then read next document. If both documents are same then user gets a message that both documents are same.
import os
import win32com.client
import numpy as np
import pandas as pd
import openpyxl
import threading
from tkinter import *
from tkinter import ttk
from tkinter import messagebox
# import pythoncom to enable 'win32com.client.Dispatch' in Threads
import pythoncom
# import psutil to check whether any application is open or not, in this case checking Catia
import psutil
class STD_Check_compare():
def __init__(self):
#Form
self.root = Tk()
self.root.geometry("700x200")
self.root.title("STD Check")
self.mainframe = ttk.Frame(self.root, padding="3 3 12 12")
self.mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
#==========================================================================================================
def STD_Check(self):
self.STD_Check_button["state"] = "disable"
global document_new # defined as global
pythoncom.CoInitialize() # to enable 'win32com.client.Dispatch' in Threads
Cat = win32com.client.Dispatch('catia.application')
Cat.Visible = True
Cat.DisplayFileAlerts = True
document_new = Cat.ActiveDocument #calling the active document
self.progressbar_STDCheck.start()
#Do something
self.progressbar_STDCheck.stop()
messagebox.showinfo("", "STD Check done for parameters. Excel created and stored in defined folder")
self.STD_Check_button["state"] = "normal"
def STD_Compare(self):
self.STD_Compare_button["state"] = "disable"
pythoncom.CoInitialize()
Cat = win32com.client.Dispatch('catia.application')
Cat.Visible = True
Cat.DisplayFileAlerts = True
document_old = Cat.ActiveDocument
if document_old == document_new:
messagebox.showinfo("", "You have selected same STD file. Select old STD to compare")
self.STD_Compare_button["state"] = "normal"
return
self.progressbar_STDCompare.start()
#do something
self.progressbar_STDCompare.stop()
messagebox.showinfo("", "STD Comparison done in DMU")
self.STD_Compare_button["state"] = "normal"
def Thread_STD_Check(self):
threading.Thread(target=self.STD_Check, daemon=True).start() # Calling STD_Check method
def Thread_STD_Compare(self):
threading.Thread(target=self.STD_Compare, daemon=True).start() # Calling STD_Compare method
#---------------Buttons, labels and Progress bars in Frame--------------------------
def display(self):
#Create Label "Enter path"
self.Label_path = ttk.Label(self.mainframe, text="Enter path to store Excel files").grid(column=1, row=3, sticky=W)
#Create Entrybox for Enter path
self.storepath = StringVar()
self.path_entry = ttk.Entry(self.mainframe, width=50, textvariable = self.storepath)
self.path_entry.grid(column=1, row=4, sticky=W)
#Create Label "STD Check"
self.Label1 = ttk.Label(self.mainframe, text="Press submit button for STD Check").grid(column=1, row=7, sticky=W)
#Create Submit Button for STD Check (Call thread for STD Check)
self.STD_Check_button = ttk.Button(self.mainframe, text="Submit", command=self.Thread_STD_Check) #to check STD
self.STD_Check_button.grid(column=2, row=7, sticky=W)
#Create Label "STD Compare"
self.Label2 = ttk.Label(self.mainframe, text="Press submit button to compare STD").grid(column=1, row=10, sticky=W)
#Create Submit Button for STD Comparison(Call thread for STD Comparison)
self.STD_Compare_button = ttk.Button(self.mainframe, text="Submit", command=self.Thread_STD_Compare) #to compare STD
self.STD_Compare_button.grid(column=2, row=10, sticky=W)
self.progressbar_STDCheck = ttk.Progressbar(self.mainframe, style='text.Horizontal.TProgressbar', mode='indeterminate', length=150)
self.progressbar_STDCheck.grid(column = 3, row = 7)
self.progressbar_STDCompare = ttk.Progressbar(self.mainframe, style='text.Horizontal.TProgressbar', mode='indeterminate', length=150)
self.progressbar_STDCompare.grid(column = 3, row = 10)
self.root.mainloop()
start = STD_Check_compare()
start.display()

python tkinter infinite loop freezes

im currently making a tkinter app that auto backup files by watching the last mod
time of the file. code is as below.
from tkinter import *
from tkinter import filedialog
import shutil
import os
from datetime import datetime
app = Tk()
app.title("7dtd auto backup")
app.geometry("800x500")
stopsign = False
def stop():
global stopsign
stopsign = True
def getSrcFolderPath():
folder_selected = filedialog.askopenfilename()
src_text.set(folder_selected)
def getDstFolderPath():
folder_selected = filedialog.askdirectory()
dst_text.set(folder_selected)
def watchpath(file, folder):
global stopsign
file = file.get()
folder = folder.get()
backupnum = 1
if file != "":
lastmtime = os.path.getmtime(file)
while stopsign == False:
if os.path.getmtime(file) != lastmtime:
lastmtime = os.path.getmtime(file)
shutil.copytree(os.path.dirname(file), folder+"/backup"+str(backupnum))
backupnum += 1
src_text = StringVar() #source file selector
src_label = Label(app, text="save file")
src_label.grid(row=0, column=0)
src_entry = Entry(app, textvariable=src_text)
src_entry.grid(row=0, column=1)
src_btn = Button(app, text="browse", width=12, command=lambda: getSrcFolderPath())
src_btn.grid(row=0, column=2)
dst_text = StringVar()
dst_label = Label(app, text="destination folder")
dst_label.grid(row=0, column=3)
dst_entry = Entry(app, textvariable=dst_text)
dst_entry.grid(row=0, column=4)
dst_btn = Button(app, text="browse", width=12, command=lambda: getDstFolderPath())
dst_btn.grid(row=0, column=5)
start_btn = Button(app, text="start", width=12, command=lambda: watchpath(src_text, dst_text))
start_btn.grid(row=2, column=0)
end_btn = Button(app, text="end", width=12, command=lambda: stop())
end_btn.grid(row=2, column=1)
app.mainloop()
the idea is that im setting an infinite loop for the function to keep fetching the last mod time of the file until it has changed, but doing so will make my app freeze during the loop, which means that the app can only be stopped by closing. Is there a way to make it not freeze while still maintaining the function of detecting the change in last mod time?
Much appreciated!

The tkinter package offers a widget.after() function that allows you to call a function of your choice after a delay of X milliseconds. It's signature is as follows: w.after(delay_ms, callback=None, *args_for_your_function)
To make your code work, you can declare lastmtime as a global variable at the start of your code and then change your watchpatch function to the following:
def watchpath(fileVar, folderVar):
print("watchpatch firing...")
global stopsign
global lastmtime
if stopsign:
stopsign = False
print("Stopping watchpath!")
return
file = fileVar.get()
folder = folderVar.get()
backupnum = 1
if file != "" and os.path.getmtime(file) != lastmtime:
lastmtime = os.path.getmtime(file)
while os.path.exists(folder+"/backup"+str(backupnum)):
backupnum += 1
print("Copying folder contents to backup folder...")
shutil.copytree(os.path.dirname(file), folder+"/backup"+str(backupnum))
backupnum += 1
app.after(1000, watchpath, fileVar, folderVar)
Points to note:
Your program actually seems to copy the entire contents of the srcfile directory to the specified backup directory, not just the individual file. I've left this logic as-is, but you might want to change it if your goal is to backup just the one file.
I added in some basic print statements to help you understand what's happening. Remove these once you're good to go.

Simultaneous use of a checkbutton and a button

I am new to Python and obviously missing something important when working with checkbuttons. Here's the idea behind my program: I select a file manually and then, depending on whether the checkbox is checked or not, trigger either one calculation sequence or another using a button. To achieve this, I wanted to verify the state of the checkbox using the .get() command.
What I've found is that only one sequence is triggered all the time independently of the state of the checkbox. .get() is not updated when I click on the checkbox. What am I doing wrong? Any help will be greatly appreciated.
from tkinter import *
from tkinter import filedialog
import tkinter as tk
master = Tk()
root = tk.Tk()
col_sep = "\t"
col_h_b = [] # field column for background
col_m_b = [] # magnetization column for background
def choose_b_file():
root.fileName_b = filedialog.askopenfilename(filetypes=((".dat files", "*.dat"), ("All files", "*.*")))
with open(root.fileName_b, 'r') as f:
for line in f:
if line[0] != "#":
linedata = [float(line.split(col_sep)[i]) for i in range(len(line.split(col_sep)))]
col_h_b.append(linedata[4])
col_m_b.append(linedata[5])
print(f.name)
offset = BooleanVar()
checkbox = tk.Checkbutton(root, text="offset subtraction", variable=offset,onvalue=1, offvalue=0)
checkbox.pack()
def plot():
if offset.get() == 1:
#some mathematical operations and graph plotting
else:
#other mathematical operations and graph plotting
def close_window():
exit()
b_data = Button(master, text="Background", width=20, command=choose_b_file)
m_minus_b = Button(master, text="Plot", width=5, command=plot)
quit = Button(master, text="Quit", width=5, command=close_window)
b_data.pack()
m_minus_b.pack()
quit.pack()
root.mainloop()

You are mostly messing parents widgets root and master.
Do you need to have a separate window for the checkbox ?
Otherwise the quick fix is to replace root by master in the checkbox creation :
checkbox = tk.Checkbutton(root, text="offset subtraction" ...)
You can also simplify the boolean stuff, the default behavior for the checkbutton is to use 0 and 1, and remove the master or the root, choose only one.
from tkinter import *
from tkinter import filedialog
root = Tk()
col_sep = "\t"
col_h_b = [] # field column for background
col_m_b = [] # magnetization column for background
def choose_b_file():
root.fileName_b = filedialog.askopenfilename(filetypes=((".dat files", "*.dat"), ("All files", "*.*")))
with open(root.fileName_b, 'r') as f:
for line in f:
if line[0] != "#":
linedata = [float(line.split(col_sep)[i]) for i in range(len(line.split(col_sep)))]
col_h_b.append(linedata[4])
col_m_b.append(linedata[5])
print(f.name)
def plot():
if offset.get() == 1:
print('True')
#some mathematical operations and graph plotting
else:
print('False')
#other mathematical operations and graph plotting
def close_window():
exit()
offset = IntVar()
checkbox = Checkbutton(root, text="offset subtraction", variable=offset)
checkbox.pack()
b_data = Button(root, text="Background", width=20, command=choose_b_file)
m_minus_b = Button(root, text="Plot", width=5, command=plot)
quit = Button(root, text="Quit", width=5, command=close_window)
b_data.pack()
m_minus_b.pack()
quit.pack()
root.mainloop()

Can't run functions in sequence. Python

So, I'm working on Tkinter and my goal is to when the user presses a button it opens a new window that he can insert data on database and then it populates a table again so it shows the new data inserted. The new window opens fine and data is indeed inserted, but the list is not updated and I don't know why.
Button code:
self.inserir = Button(self.container2, text="Inserir", command=lambda:self.help(tm.FazTela(bd),self.populate()))
Function code that gets the functions as a list and run them:
def help(*functions):
def func(*args, **kwargs):
return_value = None
for function in functions:
return_value = function(*args, **kwargs)
return return_value
return func
If I call the populate function before the function that generates the window it runs nicely but that's not what I want, I want to update after the user has input data.
I don't know if it helps, but here's the code of the window that opens once the button is pressed:
from Tkinter import *
from database import database as db
from database import tratamentos as tr
import tkMessageBox
class TelaMenor():
def __init__(self):
self.root = None
self.OPTIONS = []
self.cor1 = '#D32F2F'
def CloseWindow(self):
self.root.destroy()
self.root = None
def SendToTR(self,nome,valor,tipo,bd):
try:
tr.ProdutosRecieve(nome,valor,tipo,bd)
except:
tkMessageBox.showerror("Erro encontrado", "Digite valores validos!")
finally:
self.CloseWindow()
def FazTela(self,bd):
if(self.root!=None):
self.CloseWindow()
self.FazTela()
else:
self.root=Tk()
# opcoes do droplist
self.OPTIONS = [
"Tipo de produto",
"Doce",
"Salgado",
"Massa",
"Bebida",
"Outro"
]
#fim
# criacao e posicao dos widgets
info = Frame(self.root)
info.grid(sticky=N+S+W+E)
salto1 = Label(info, text=" ")
salto1.grid(row=0, column=0)
nome1 = Label(info, text="Nome:")
nome1['font']=['bold']
nome1.grid(row=1, column=1, sticky=W)
nome2 = Entry(info)
nome2["width"]=40
nome2.grid(row=2, column=1)
salto2 = Label(info, text="")
salto2.grid(row=3, column=0)
valor1 = Label(info, text="Valor:")
valor1['font']=['bold']
valor1.grid(row=4, column=1, sticky=W)
valor2 = Entry(info)
valor2["width"]=40
valor2.grid(row=5, column=1)
salto3 = Label(info, text="")
salto3.grid(row=6, column=0)
variable = StringVar(info)
variable.set(self.OPTIONS[0])
droplist = apply(OptionMenu, (info, variable) + tuple(self.OPTIONS))
droplist.grid(row=7, column=1)
salto4 = Label(info, text="")
salto4.grid(row=8, column=0)
pronto = Button(info, text="Pronto", bg=self.cor1, bd=3,command=lambda: self.SendToTR(nome2.get(),valor2.get(),variable.get(),bd))
pronto['font']=['bold']
pronto['fg']='white'
pronto.grid(row=9, column=1)
salto5 = Label(info, text="")
salto5.grid(row=10, column=1)
espaco1 = Label(info, text=" ")
espaco1.grid(row=10, column=2)
#fim
# barra de "status"
status = Label(info, text="Estado: Normal", bg="white", bd=1, relief=SUNKEN, anchor=W)
status.grid(row= 11, column=0, sticky=S+W+E, columnspan=3)
#fim
# formatacao da janela
self.root.title('Cadastro do Produto')
#root.iconbitmap(r'c:\Python27\DLLs\icon.ico')
self.root.resizable(width=False, height=False)
self.root.geometry('298x276')
self.root.protocol("WM_DELETE_WINDOW",lambda: self.CloseWindow())
self.root.mainloop()
#fim
Sorry, there are some words in portuguese.

This is a good illustration of why you shouldn't use lambda unless absolutely necessary: it makes debugging difficult. I recommend removing the use of lambda, and instead tie the button to a normal function. Doing so will make it easier to insert debugging code.
In this case, your function is running this code:
self.help(tm.FazTela(bd),self.populate())
This is the same as doing this:
a = tm.FazTela(bd)
b = self.populate()
self.help(a,b)
You also have the problem that you are creating more than one root window. In tkinter you must always have exactly one root window. Instead of creating a second instance of Tk, you need to create an instance of Toplevel.
If you want to execute code after the window has been destroyed you can use the function wait_window which will not return until the given window has closed.