Sending of variable captured from a form .pyw with tkinter to an independent function in a .py

If I do not understand wrong, your execution flow would be:

Is it correct?

That approach can not work, for two reasons:

The graphic application must find another way to send the data to the first one. Leaving them in a shared variable is not possible. Other possible approaches:

• Leave them in a temporary file, which the original script would read once the sub-script has finished.
• Make the graphic script issue the data in question by its standard output (for example separated by commas). The main script that launches to the other may try to capture the standard output of the other (use popen() instead of os.system() ) and parsear the string you get (separate by commas, etc.)
• Change the design to use a single process.

Enlargement

If you have everything in one process, then you have simpler ways to communicate information between objects.

The most obvious is to do it through a return . That is, one object invokes a method of another and that other returns the value that the first expects. You do not need shared variables in this case. You can base yourself on the example given in this answer

You can also use your original approach to save it in a class variable, but in that case you should not use self.variable = dato for it, because as it explained at the beginning of this answer, that creates a new variable in the instance (object ), without modifying the same variable of the class. You should use instead clase.variable = dato (in your case FunctionClass._PDFDatos = [...] ).

However, I see a problem with this approach. How do you synchronize the execution of step 5? In that step you try to access the class variable but how do you know if that variable has already been set? That will not happen until the user has written something in the GUI, and that is asynchronous in nature. Somehow you have to synchronize those threads.

You should only use a second process or thread if the script and the form should be executed asynchronously, so that when your main script calls the form this is displayed, but the main script continues with its execution doing other things while the user interacts with the form. This implies that you will have to synchronize both processes / threads and share information securely between them, for example through queues.

However I think you want your dialogue to behave as "modal", thus blocking the execution of the code until the user accepts or closes it and continues from there with the execution of the main script. In that case you are complicating yourself a lot without need. The call to mainloop is a blocking call and the cycle is executed in the same process in which it is launched, thus blocking execution at that point.

Therefore, you can simply instantiate and launch the form in your CambiarNombrePDF method, which will block the execution of that function at that point until the mainloop ends, at which time you can access the data without problems. the instance of the form. There are many ways to implement it, an example based on your code (there are missing data, but it can be reproduced):

import tkinter as tk



class NameForm(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Set customer")
        frame = tk.Frame(self)
        frame.grid()

        self.user_name = tk.StringVar()
        self.user_last = tk.StringVar()
        self.user_num = tk.StringVar()
        self.file_type = tk.StringVar()

        tk.Label(frame, text="Enter customer's Name: ").grid(row=1, column=1, sticky=tk.W)
        tk.Entry(frame, textvariable=self.user_name).grid(row=1, column=200, sticky=tk.W)
        tk.Label(frame, text="Enter customer's Last Name: ").grid(row=2, column=1,
            rowspan=1, columnspan=6, sticky=tk.W)
        tk. Entry(frame, textvariable=self.user_last).grid(row=2, column=200, sticky=tk.W)
        tk.Label(frame, text="Enter customer's Last 4 SSN: ").grid(row=3, column=1,
            rowspan = 1, columnspan = 6, sticky=tk.W)        
        tk.Entry(frame, textvariable = self.user_num).grid(row=3, column=200, sticky=tk.W)
        tk.Label(frame, text="Enter Document Type: ").grid(row=4, column=1, rowspan=1,
            columnspan = 6, sticky=tk.W)       
        tk.Entry(frame, textvariable = self.file_type).grid(row=4, column=200, sticky=tk.W)
        tk.Button(frame, text="ACCEPT", command=self.on_accept).grid(row=6,
            column=3,sticky=tk.E + tk.W)

    def on_accept(self):  
        # Puedes aprobechar esto para validar los datos antes de cerrar
        self.destroy()

    def get_data(self):
        self.mainloop()
        user_name = self.user_name.get()
        user_last = self.user_last.get()
        user_num = self.user_num.get()
        file_type = self.file_type.get()
        return [user_name, user_last, user_num, file_type]       


class FunctionsClass:

    def __init__(self):
        self._pdf_datos = []

    def cambiar_nombre_pdf(self, dir_pdf, convert_to_pdf):
        print("Lanzando formulario")
        formulario = NameForm()
        self._pdf_datos = formulario.get_data()
        print("Formulario cerrado")
        print(self._pdf_datos)



if __name__ == "__main__":
    inst = FunctionsClass()
    inst.cambiar_nombre_pdf(None, None)

The class of the form can be placed in another module and imported if you prefer.

Class attributes are shared among all instances of the class in the process, however, if a referencing occurs through the instance and not through the class, a new instance attribute is created with the same name that leaves intact and overlaps the class attribute for that instance. In this case you do not need a class attribute in principle. For more information you can look at this question:

• Difference between instance attributes and class attributes

Edit

In response to the questions raised:

• inst = FunctionsClass() simply creates an instance of the class FunctionsClass and inst.cambiar_nombre_pdf(None, None) calls the instance method cambiar_nombre_pdf , which in your code receives two parameters that I have maintained ( dir_pdf and convert_to_pdf ). These arguments are not used in the function, if you do not use them you must eliminate them. As I do not know very well the utility that you give them, I pass None to both to fulfill the signature of the function simply and that it can be executed. All this I suppose would already take place somewhere in your code that you do not sample. In terms of if __name__ == "__main__" , its usefulness is to include code that will be executed only when the module is executed as the main one, not when it is imported, for more information see:

  What is if __name__ == "__main __":?

• As for def __init__(self) , it is the initializer of the class, it is explained in more detail in:

  What is a constructor?

• super().__init__(self) is responsible for calling the parent's initializer ( Frame in your case and Tk in mine). This is necessary because we have overwritten the __init__ inherited from the parent class. For our class to have all the functionality of the parent class that is carried out in its initializer, it is necessary to call it explicitly. The same does Frame.__init__(self, master) , but forces us to hardcodear the name of the parent class. For more information see:

  What is it and what Does utility have super in OOP?