tk_form is a simple module that helps you to create forms in tkinter easily and quickly from a base dictionary, saving certain repetitive tasks in the creation of a form and adding the verification of integer and float variables. In simple words it is similar to having a tkinter variable. Its value is a dictionary.
pip install tkinter_formimport tkinter as tk
from tkinter_form import Form
class App(tk.Tk):
def __init__(self) -> None:
super().__init__()
estruct = {
"high": 1.0,
"width": 1.0,
"round": False,
"type of calculation": ["calculate area", "calculate perimeter"],
"result": "",
}
self.form = Form(
self,
name_form="calculations of a rectangle",
form_dict=estruct,
name_config="calculate",
button=True
)
self.form.pack()
self.button = self.form.button
self.button.config(command=self.calculate)
self.mainloop()
def calculate(self):
"""
Calculate values rectangle
"""
dict_vals = self.form.get()
if dict_vals["type of calculation"] == "calculate area":
value = dict_vals["high"] * dict_vals["width"]
elif dict_vals["type of calculation"] == "calculate perimeter":
value = 2 * dict_vals["high"] 2 * dict_vals["width"]
else:
value = 0
if dict_vals["round"]:
value = round(value)
result = {"result": str(value)}
self.form.set(result)
if __name__ == "__main__":
App()With these lines we create the interface that performs the calculations of area and perimeter of a rectangle. This frees us the declaration of the labels and other objects returning a ttk.LabelFrame with the additional methods set(), get() and the attributes widgets and button.
tkinter_form.Form(self,master: object, name_form: str, form_dict: dict, name_config: str = "configure", button: bool = True)Form object is a ttk.LabelFrame. With additional attributes: self.widgets, self.button, self.get(), self.set() , self.set_labels_text() .
Parameters:
master : tk.Tk or object tk.parent tkinter container or parent object
name_form : str string with edit`ttk.LabelFrame['text']
form_dict : dict[str:float|int|str|bool|list] base structure of the form that contains the initial values of the form.Struct Form
name_config: str
name of the form button in case the argumentbutton is True button : bool Create a button on the form by default
Attributes:
button : ttk.Button | None
if the button is create in the form.
widgets : dict[str:[ttk.Label,ttk.Entry|ttk.CheckButton|ttk.ComboBox] | tkinter_form.Form]
dictionary that contains the widgets of the form with the same structure of the dictionary that was built. returning a list with two objects a tk.Label and a tk object according to the data type.
Methods:
get(): Return Dict
Returns a dictionary with the same structure that was created which contains the values entered in the form
set(set_dict) : Return None
set_dict: dict
dictionary with keys value of the base dictionary with values to set in the form
set_labels_text(set_labels) : Return None
set_labels: dict
dictionary with keys value of the base dictionary with values to set labels text in the form.
is a ttk.buttom or None if the form button was not created
dictionary that contains the widgets of the form with the same structure of the dictionary that was built. returning a list with two objects a tk.Label and a tk object according to the data type.
in Fast Example the widget attibute return:
{
"high": [ttk.Label, ttk.Entry],
"width": [ttk.Label, ttk.Entry],
"round": [ttk.Label, ttk.CheckButtom],
"type of calculation": [ttk.Label, ttk.ComboBox],
"result": [ttk.Label, ttk.Entry],
}If in Fast Example we want the ttk.Entry result to be read-only we could:
class App(tk.Tk):
def __init__(self) -> None:
:::
entry = self.form.widgets["result"][1]
entry.config(state='readonly')If the structure of the form contains subdictionaries in said key, a Form will be assigned.
Estruct example:
{
"measures":{
"high": 1.0,
"width": 1.0
},
"round": False,
"type of calculation": ["calculate area", "calculate perimeter"],
"result": "",
}the`widget` attribute would be
{
"measures":tkinter_form.Form,
"round": [ttk.Label, ttk.CheckButtom],
"type of calculation": [ttk.Label, ttk.ComboBox],
"result": [ttk.Label, ttk.Entry],
}Arguments:
Return: None Returns a dictionary with the same structure that was created which contains the values entered in the form.
in [Fast Example](#fast-example) the get() function return:
{
"high": 3.7,
"width": 5,
"round": True,
"type of calculation": "calculate perimeter",
"result": "17",
}if struct Form Contain Subdictionaries
Estruct example:
{
"measures":{
"high": 1.0,
"width": 1.0
},
"round": False,
"type of calculation": ["calculate area", "calculate perimeter"],
"result": "",
}the`get()` function return por example
{
"measures":{
"high": 3.7,
"width": 5
},
"round": True,
"type of calculation": "calculate perimeter",
"result": "17",
}Arguments: set_dict : dict
Return: None
dictionary with keys value of the base dictionary with values to set in the form
in [Fast Example](#fast-example) the set() function in line 39-40:
result = {"result": str(value)}
self.form.set(result)Arguments: set_dict : dict
Return: None
dictionary with keys value of the base dictionary with values to set in the form
in [Fast Example](#fast-example) the set_labes_text():
rename_labels = {
"__form__": "Calculos Rectangulo",
"measures": {
"__form__": "medidas",
"width": "ancho",
"high": "alto",
},
"round": "redondear",
"type of calculation": "tipo de calculo",
"result": "resultado",
}
self.form.set_labels_text(rename_labels)Result:
tkinter_form.Value(self,val: Any, description:str)If the base dictionary value is an instance of the Value class, it's description parameter is displayed on the row following the editing widget.
{
"high": Value(3.7, "The high vale"),
"width": Value(5, "The width is used in the calculation"),
"round": Value(True, "Whether to round the result"),
"type of calculation": "calculate perimeter",
"result": "17",
}The form structure is based on a base dictionary. with some initial values that will be displayed in the interface and that determine the type of data that the entry accepts. This means that if the value in the base dictionary is an integer, the entry will only allow the entry of integer values.
-
dictionary keys are recommended to be strings but not required. But care must be taken. The Form.widgets will have as keys the same values entered in the base structure.
-
The comboboxes are generated by means of lists, these cannot be empty since their initial value is the first index of the list.
- example 1
estruct = {
"high": float(),
"width": float(),
"round": bool(),
"type of calculation": ["val 1", "val 2"],
"result": str(),
}
- example 2
estruct = {
"measurements":{
"high": 5.0,
"width": float()
},
"round": bool(),
"type of calculation": ["val 1", "val 2"],
"result": str(),
}
- example 2
estruct = {
"Company:": "company.SAS",
"Fisrt Name:": "Job",
"Last Name:": "Job",
"Email Address:": "company.SAS",
"Title:": "",
"Phone:": int(),
"Cancel Registration:": True,
"Job Function:":["Campaing Management", "CRM Administration", "Partner", "Employee"],
"Dietary Requirements:":str()
}
- get() function on integer values returns the value difenter if in the Entry the value starts with zero. Example:
estruct = {"value": int()}
return get()
{'value': 55}