replace more "with open"

.idea/workspace.xml

@@ -5,7 +5,7 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="940e1630-c825-4d4c-be80-bc11f543c122" name="Changes" comment=" - Update Translate Files">
-      <change beforePath="$PROJECT_DIR$/cls_mth_fc.py" beforeDir="false" afterPath="$PROJECT_DIR$/cls_mth_fc.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/wirepy.py" beforeDir="false" afterPath="$PROJECT_DIR$/wirepy.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
@@ -43,28 +43,28 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;ASKED_ADD_EXTERNAL_FILES&quot;: &quot;true&quot;,
-    &quot;Python.INSTALL.executor&quot;: &quot;Run&quot;,
-    &quot;Python.cls_mth_fc.executor&quot;: &quot;Run&quot;,
-    &quot;Python.install.executor&quot;: &quot;Run&quot;,
-    &quot;Python.main.executor&quot;: &quot;Run&quot;,
-    &quot;Python.messagebox.executor&quot;: &quot;Run&quot;,
-    &quot;Python.start_wg.executor&quot;: &quot;Run&quot;,
-    &quot;Python.testtheme.executor&quot;: &quot;Run&quot;,
-    &quot;Python.wg_func.executor&quot;: &quot;Run&quot;,
-    &quot;Python.wg_main.executor&quot;: &quot;Run&quot;,
-    &quot;Python.wirepy.executor&quot;: &quot;Run&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
-    &quot;Shell Script.install.executor&quot;: &quot;Run&quot;,
-    &quot;Shell Script.run_as.executor&quot;: &quot;Run&quot;,
-    &quot;git-widget-placeholder&quot;: &quot;21-04-2025-new-tooltip&quot;,
-    &quot;last_opened_file_path&quot;: &quot;/home/punix/Pyapps/wire-py&quot;,
-    &quot;settings.editor.selected.configurable&quot;: &quot;ml.llm.LLMConfigurable&quot;
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ASKED_ADD_EXTERNAL_FILES": "true",
+    "Python.INSTALL.executor": "Run",
+    "Python.cls_mth_fc.executor": "Run",
+    "Python.install.executor": "Run",
+    "Python.main.executor": "Run",
+    "Python.messagebox.executor": "Run",
+    "Python.start_wg.executor": "Run",
+    "Python.testtheme.executor": "Run",
+    "Python.wg_func.executor": "Run",
+    "Python.wg_main.executor": "Run",
+    "Python.wirepy.executor": "Run",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "Shell Script.install.executor": "Run",
+    "Shell Script.run_as.executor": "Run",
+    "git-widget-placeholder": "28-04-2025-more-methods-and-optimize-methods",
+    "last_opened_file_path": "/home/punix/Pyapps/wire-py",
+    "settings.editor.selected.configurable": "ml.llm.LLMConfigurable"
   }
-}</component>
+}]]></component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
       <recent name="$PROJECT_DIR$/lx-icons" />

cls_mth_fc.py

@@ -135,8 +135,7 @@ class LxTools(tk.Tk):
         """
         log_name: str = f"{Path.home()}"[6:]
         file: Path = Path.home() / "/tmp/.log_user"
-        with open(file, "w", encoding="utf-8") as f:
-            f.write(log_name)
+        Path(file).write_text(log_name, encoding="utf-8")
 
     @staticmethod
     def clean_files(folder_path: Path = None, file: Path = None) -> None:
@@ -156,13 +155,12 @@ class LxTools(tk.Tk):
         """
         method that writes in file whether tooltip is displayed or not
         """
-        with open(path, "r", encoding="utf-8") as set_f2:
-            lines2 = set_f2.readlines()
-            if "False\n" in lines2:
-                tip = False
-            else:
-                tip = True
-            return tip
+        lines = Path(path).read_text(encoding="utf-8")
+        if "False\n" in lines:
+            tip = False
+        else:
+            tip = True
+        return tip
 
     @staticmethod
     def msg_window(img_w: str, img_i: str, w_title: str, w_txt: str, txt2: Optional[str] = None,

ssl_decrypt.py

@@ -8,8 +8,7 @@ from subprocess import check_call
 
 uname: Path = Path("/tmp/.log_user")
 
-with open(uname, "r", encoding="utf-8") as f:
-    log_name = f.readline()
+log_name = Path(uname).read_text(encoding="utf-8")
 
 # Folder Name "tlecdewg" = Tunnel Encrypt Decrypt Wireguard
 folder_path: Path = Path("/tmp/tlecdcwg/")
@@ -31,5 +30,6 @@ if os.path.exists(f"{folder_path2}pbwgk.pem"):
     for detunnels in detl:
         tlname2 = f"{detunnels[:-4]}.conf"
         extpath = f"{folder_path}/{tlname2}"
-        check_call(["openssl", "pkeyutl", "-decrypt", "-inkey", PKEYFILE, "-in", detunnels, "-out", extpath])
+        check_call(["openssl", "pkeyutl", "-decrypt", "-inkey", PKEYFILE, "-in", detunnels,
+                    "-out", extpath])
         shutil.chown(extpath, 1000, 1000)

ssl_encrypt.py

@@ -8,8 +8,7 @@ from subprocess import check_call
 
 uname: Path = Path("/tmp/.log_user")
 
-with open(uname, "r", encoding="utf-8") as f:
-    log_name: str = f.readline()
+log_name = Path(uname).read_text(encoding="utf-8")
 
 keyfile: Path = Path(f"/home/{log_name}/.config/wire_py/pbwgk.pem")
 folder_path: Path = Path("/tmp/tlecdcwg/")

start_wg.py

@@ -7,12 +7,9 @@ from subprocess import check_call
 
 path_to_file = Path(Path.home() / ".config/wire_py/settings")
 
-with open(path_to_file, "r", encoding="utf-8") as a_con:
-
-    # This function is for the independent autostarted of the previously selected tunnel
-    lines = a_con.readlines()
-    a_con = lines[7].strip()
-    if a_con != "off":
-        check_call(["nmcli", "connection", "up", a_con])
-    else:
-        pass
+a_con = Path(path_to_file).read_text(encoding="utf-8").splitlines(keepends=True)
+a_con = a_con[7].strip()
+if a_con != "off":
+    check_call(["nmcli", "connection", "up", a_con])
+else:
+    pass

wirepy.py

@@ -23,6 +23,8 @@ Create.decrypt()
 
 tcl_path: Path = Path("/usr/share/TK-Themes")
 set_file: Path = Path(Path.home() / ".config/wire_py/settings")
+keys: Path = Path(Path.home() / ".config/wire_py/keys")
+ 
 tips = LxTools.if_tip(set_file)
 folder_path: Path = Path("/tmp/tlecdcwg/")
 user_file = Path("/tmp/.log_user")
@@ -73,12 +75,12 @@ class Wirepy(tk.Tk):
 
         self.style = ttk.Style(self)
         self.tk.call("source", f"{tcl_path}/water.tcl")
-        with open(set_file, "r", encoding="utf-8") as read_file:
-            lines = read_file.readlines()
-            if "light\n" in lines:
-                self.tk.call("set_theme", "light")
-            else:
-                self.tk.call("set_theme", "dark")
+
+        lines = set_file.read_text()
+        if "light\n" in lines:
+            self.tk.call("set_theme", "light")
+        else:
+            self.tk.call("set_theme", "dark")
 
         # Load the image file from the disk
         self.wg_icon = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/48/wg_vpn.png")
@@ -110,79 +112,6 @@ class FrameWidgets(ttk.Frame):
         self.exp_pic = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/48/wg_export.png")
         self.warning_pic = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/64/error.png")
 
-        def update():
-            """
-            Set on or off in file
-            """
-            if set_update.get() == 1:
-                with open(set_file, "r", encoding="utf-8") as set_f2:
-                    lines2 = set_f2.readlines()
-                    lines2[1] = "off\n"
-                with open(set_file, "w", encoding="utf-8") as set_f2:
-                    set_f2.writelines(lines2)
-
-            if set_update.get() == 0:
-                with open(set_file, "r", encoding="utf-8") as set_f2:
-                    lines2 = set_f2.readlines()
-                    lines2[1] = "on\n"
-                with open(set_file, "w", encoding="utf-8") as set_f2:
-                    set_f2.writelines(lines2)
-
-        def theme_change_light():
-            """
-            Set a light theme
-            """
-            if self.tk.call("ttk::style", "theme", "use") == "water-dark":
-                self.tk.call("set_theme", "light")
-                with open(set_file, "r", encoding="utf-8") as theme_set2:
-                    lines3 = theme_set2.readlines()
-                    lines3[3] = "light\n"
-                with open(set_file, "w", encoding="utf-8") as theme_set2:
-                    theme_set2.writelines(lines3)
-                self.color_label()
-
-        def theme_change_dark():
-            """
-            Set a dark theme
-            """
-            if not self.tk.call("ttk::style", "theme", "use") == "water-dark":
-                self.tk.call("set_theme", "dark")
-                with open(set_file, "r", encoding="utf-8") as theme_set2:
-                    lines4 = theme_set2.readlines()
-                    lines4[3] = "dark\n"
-                with open(set_file, "w", encoding="utf-8") as theme_set2:
-                    theme_set2.writelines(lines4)
-                self.color_label()
-
-        def tooltip():
-            """
-            Set True or False in a file
-            """
-            if set_tip.get():
-                with open(set_file, "r", encoding="utf-8") as set_f2:
-                    lines2 = set_f2.readlines()
-                    lines2[5] = "False\n"
-                with open(set_file, "w", encoding="utf-8") as set_f2:
-                    set_f2.writelines(lines2)
-
-            else:
-                with open(set_file, "r", encoding="utf-8") as set_f2:
-                    lines2 = set_f2.readlines()
-                    lines2[5] = "True\n"
-                with open(set_file, "w", encoding="utf-8") as set_f2:
-                    set_f2.writelines(lines2)
-
-        def info():
-            def link_btn():
-                webbrowser.open("https://git.ilunix.de/punix/Wire-Py")
-
-            msg_t = _("Wire-Py a simple Wireguard Gui for Linux systems.\n\n"
-                    "Wire-Py is open source software written in Python.\n\n"
-                    "Email: polunga40@unity-mail.de also likes for donation.\n\n"
-                    "Use without warranty!\n")
-
-            LxTools.msg_window(img_i, img_i, _("Info"), msg_t, _("Go to Wire-Py git"), link_btn)
-
         # Frame for Menu
         self.menu_frame = ttk.Frame(self)
         self.menu_frame.configure(relief="flat")
@@ -204,15 +133,16 @@ class FrameWidgets(ttk.Frame):
         set_tip = tk.BooleanVar()
         self.settings = tk.Menu(self, relief="flat")
         self.options_btn.configure(menu=self.settings, style="Toolbutton")
-        self.settings.add_checkbutton(label=_("Disable Updates"), command=update, variable=set_update)
-        self.settings.add_checkbutton(label=_("Disable Tooltips"), command=tooltip, variable=set_tip)
-        self.settings.add_command(label=_("Light"), command=theme_change_light)
-        self.settings.add_command(label=_("Dark"), command=theme_change_dark)
+        self.settings.add_checkbutton(label=_("Disable Updates"),
+                                      command=lambda: self.update_setting(set_update.get()), variable=set_update)
+        self.settings.add_checkbutton(label=_("Disable Tooltips"),
+                                      command=lambda: self.tooltip(set_tip.get()), variable=set_tip)
+        self.settings.add_command(label=_("Light"), command=self.theme_change_light)
+        self.settings.add_command(label=_("Dark"), command=self.theme_change_dark)
 
         # About BTN Menu / Label
         self.about_btn = ttk.Button(
-            self.menu_frame, text=_("About"), style="Toolbutton", command=info
-        )
+        self.menu_frame, text=_("About"), style="Toolbutton", command=self.about)
         self.about_btn.grid(column=2, columnspan=2, row=0)
         self.readme = tk.Menu(self)
 
@@ -306,23 +236,12 @@ class FrameWidgets(ttk.Frame):
         self.peer.config(font=("Ubuntu", 9))
         self.peer.grid(column=0, row=4, sticky="we", padx=130)
 
-        def enable_check_box(_):
-            """
-            checkbox for enable autostart Tunnel
-            """
-            Create.files_for_autostart()
-            if self.l_box.size() != 0:
-                self.wg_autostart.configure(state="normal")
-                self.lb_rename.config(state="normal")
-                self.lb_rename.delete(0, tk.END)
-                self.btn_rename.config(state="normal")
-
         # Listbox with Scrollbar
         self.l_box = tk.Listbox(self.lb_frame_btn_lbox, selectmode="single")
         self.l_box.config(relief="ridge", font=("Ubuntu", 12, "bold"))
         self.l_box.grid(column=1, rowspan=4, row=0, sticky="ns")
         self.l_box.event_add("<<ClickEvent>>", "<Button-1>")
-        self.l_box.bind("<<ClickEvent>>", enable_check_box)
+        self.l_box.bind("<<ClickEvent>>", self.enable_check_box)
         self.scrollbar = ttk.Scrollbar(self.lb_frame_btn_lbox, orient="vertical", command=self.l_box.yview)
         self.scrollbar.grid(column=1, rowspan=4, row=0, sticky="nse")
         self.l_box.configure(yscrollcommand=self.scrollbar.set)
@@ -336,13 +255,7 @@ class FrameWidgets(ttk.Frame):
         # Button Vpn
         if self.a != "":
             self.stop()
-            wg_read = f"/tmp/tlecdcwg/{self.a}.conf"
-            with open(wg_read, "r", encoding="utf-8") as file:
-                data = Tunnel.con_to_dict(file)
-
-            # Address Label
-            self.init_and_report(data)
-            self.show_data()
+            data = self.handle_tunnel_data(self.a)
         else:
             self.start()
 
@@ -350,7 +263,7 @@ class FrameWidgets(ttk.Frame):
             self.add = tk.StringVar()
             self.DNS = tk.StringVar()
             self.enp = tk.StringVar()
-            self.label_empty()
+            self.reset_fields()
             self.show_data()
 
         # Button Import
@@ -359,77 +272,8 @@ class FrameWidgets(ttk.Frame):
 
         Tooltip(self.btn_i, _("Click to import a Wireguard Tunnel"), tips)
 
-        def delete():
-            """
-            delete Wireguard Tunnel
-            """
-            try:
-                self.select_tunnel = self.l_box.curselection()
-                select_tl = self.l_box.get(self.select_tunnel[0])
-                with open(f"/tmp/tlecdcwg/{select_tl}.conf", "r+", encoding="utf-8") as file2:
-                    key = Tunnel.con_to_dict(file2)
-                    pre_key = key[3]
-                check_call(["nmcli", "connection", "delete", select_tl])
-                self.l_box.delete(self.select_tunnel[0])
-                with open(set_file, "r", encoding="utf-8") as set_f6:
-                    lines6 = set_f6.readlines()
-                    if (
-                            select_tl == lines6[7].strip()
-                            and "off\n" not in lines6[7].strip()
-                    ):
-                        lines6[7] = "off\n"
-                        with open(set_file, "w", encoding="utf-8") as set_f7:
-                            set_f7.writelines(lines6)
-                        self.selected_option.set(0)
-                        self.autoconnect_var.set(_("no Autoconnect"))
-                is_encrypt = Path.home() / f".config/wire_py/{select_tl}.dat"
-                if is_encrypt.is_file():
-                    Path.unlink(f"{Path.home()}/.config/wire_py/{select_tl}.dat")
-                Path.unlink(f"/tmp/tlecdcwg/{select_tl}.conf")
-                with open(f"{Path.home()}/.config/wire_py/keys", "r", encoding="utf-8") as readfile:
-                    with open(f"{Path.home()}/.config/wire_py/keys2", "w", encoding="utf-8") as writefile:
-                        for line in readfile:
-                            if pre_key not in line.strip("\n"):
-                                writefile.write(line)
-                file_one = Path(f"{Path.home()}/.config/wire_py/keys2")
-                file_two = file_one.with_name("keys")
-                file_one.replace(file_two)
-                self.wg_autostart.configure(state="disabled")
-
-                # for disabling checkbox when Listbox empty
-                if self.l_box.size() == 0:
-                    self.wg_autostart.configure(state="disabled")
-                    self.lb_rename.configure(state="disabled")
-                    Tooltip(self.wg_autostart, _("You must have at least one\ntunnel in the list,to use the autostart")
-                            , tips)
-
-                    Tooltip(self.btn_exp, _("No Tunnels in List for Export"), tips)
-                    Tooltip(self.btn_stst, _("No tunnels to start in the list"), tips)
-                    Tooltip(self.lb_rename, _("To rename a tunnel, at least one must be in the list"), tips, )
-                    self.lb_rename.insert(0, _("Max. 12 characters!"))
-
-                if self.a != "" and self.a == select_tl:
-                    self.str_var.set(value="")
-                    self.start()
-                    self.l_box.update()
-
-                    # Address Label
-                    self.add.set("")
-                    self.DNS.set("")
-                    self.enp.set("")
-
-            except IndexError:
-
-                if self.l_box.size() != 0:
-
-                    LxTools.msg_window(img_w, img_i2, sl, pstl)
-
-                else:
-
-                    LxTools.msg_window(img_w, img_i2, sl, pfit)
-
         # Button Trash
-        self.btn_tr = ttk.Button(self.lb_frame_btn_lbox, image=self.tr_pic, command=delete, padding=0,
+        self.btn_tr = ttk.Button(self.lb_frame_btn_lbox, image=self.tr_pic, command=self.delete, padding=0,
                                  style="CButton.TButton")
         self.btn_tr.grid(column=0, row=2, padx=15, pady=8)
 
@@ -459,67 +303,15 @@ class FrameWidgets(ttk.Frame):
         else:
             Tooltip(self.lb_rename, _("To rename a tunnel, at least one must be in the list"), tips)
 
-        def tl_rename():
-
-            special_characters = ["\\", "/", "{", "}", " "]
-
-            if len(self.lb_rename.get()) > 12:
-
-                LxTools.msg_window(img_w, img_i2, rnp, _("The new name may contain only 12 characters"))
-
-            elif len(self.lb_rename.get()) == 0:
-
-                LxTools.msg_window(img_w, img_i2, rnp, _("At least one character must be entered"))
-
-            elif any(ch in special_characters for ch in self.lb_rename.get()):
-
-                msg_t = _("No valid sign. These must not be used.\nBlank, Slash, Backslash and { }\n")
-                LxTools.msg_window(img_w, img_i2, rnp, msg_t)
-
-            else:
-
-                try:
-                    self.select_tunnel = self.l_box.curselection()
-                    select_tl = self.l_box.get(self.select_tunnel[0])
-
-                    # nmcli connection modify old connection.id iphone
-                    check_call(["nmcli", "connection", "modify", select_tl, "connection.id", self.lb_rename.get()])
-                    source = Path(f"/tmp/tlecdcwg/{select_tl}.conf")
-                    destination = source.with_name(f"{self.lb_rename.get()}.conf")
-                    source.replace(destination)
-                    Path.unlink(f"{Path.home()}/.config/wire_py/{select_tl}.dat")
-
-                    self.l_box.delete(self.select_tunnel[0])
-                    self.l_box.insert("end", self.lb_rename.get())
-                    self.l_box.update()
-                    new_a_connect = self.lb_rename.get()
-                    self.lb_rename.delete(0, tk.END)
-                    if self.a != "" and self.a == select_tl:
-                        self.a = Tunnel.active()
-                        self.str_var.set(value=self.a)
-                        with open(set_file, "r", encoding="utf-8") as set_f5:
-                            lines5 = set_f5.readlines()
-                        if select_tl == lines5[7].strip() and "off\n" not in lines5[7].strip():
-                            lines5[7] = new_a_connect
-                            with open(set_file, "w", encoding="utf-8") as theme_set5:
-                                theme_set5.writelines(lines5)
-                            self.autoconnect_var.set(value=new_a_connect)
-
-                    Create.encrypt()
-
-                except IndexError:
-
-                    LxTools.msg_window(img_w, img_i2, rnp, pstl)
-
         # Button Rename
-        self.btn_rename = ttk.Button(self.lb_frame4, text=_("Rename"), state="disable", command=tl_rename, padding=4,
-                                     style="RnButton.TButton")
+        self.btn_rename = ttk.Button(self.lb_frame4, text=_("Rename"), state="disable", command=self.tl_rename,
+                                     padding=4, style="RnButton.TButton")
         self.btn_rename.grid(column=3, row=0, padx=5, pady=10, sticky="ne")
 
         # Check Buttons
         self.selected_option = tk.IntVar()
         self.autoconnect_var = tk.StringVar()
-        self.autoconnect_var.set(self.auto_con)
+        self.autoconnect_var.set(f"{self.auto_con}")
 
         # Frame for Labels, Entry and Button
         self.autoconnect = ttk.Label(self.lb_frame3, textvariable=self.autoconnect_var, width=15)
@@ -541,21 +333,213 @@ class FrameWidgets(ttk.Frame):
 
         self.on_off()
 
-    def import_sl(self):
+    @staticmethod
+    def about() -> None:
         """
-        Import Methode for Wireguard config Files.
-        Before importing, it is checked whether PrivateKey and PublicKey are in the file.
-        If True, then it is checked whether the PreSharedKey is already in the key file
-        to avoid an import error so that no double wgconf are imported.
-        Thus, tunnels can be renamed without the problems arising.
-        If False, then the key is written into the file.
-        Furthermore, it is checked whether the name is longer than 12 characters.
-        If True, then the name is automatically shortened to 12 characters
-        and then imported.
-        If in each case false comes out, a corresponding window comes to
-        inform the user that something is wrong.
+        a tk.Toplevel window
         """
+        def link_btn() -> str | None:
+            webbrowser.open("https://git.ilunix.de/punix/Wire-Py")
 
+        msg_t = _("Wire-Py a simple Wireguard Gui for Linux systems.\n\n"
+                "Wire-Py is open source software written in Python.\n\n"
+                "Email: polunga40@unity-mail.de also likes for donation.\n\n"
+                "Use without warranty!\n")
+
+        LxTools.msg_window(img_i, img_i, _("Info"), msg_t, _("Go to Wire-Py git"), link_btn)
+
+    def theme_change_light(self) -> None:
+        """
+        Set a light theme
+        """
+        if self.tk.call("ttk::style", "theme", "use") == "water-dark":
+            self.tk.call("set_theme", "light")
+            lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)  # (keepends=True) = not changed
+            lines[3] = 'light\n' 
+            Path(set_file).write_text(''.join(lines), encoding="utf-8")
+            self.color_label()
+
+    def theme_change_dark(self) -> None:
+        """
+        Set a dark theme
+        """
+        if not self.tk.call("ttk::style", "theme", "use") == "water-dark":
+            self.tk.call("set_theme", "dark")
+            lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+            lines[3] = 'dark\n' 
+            Path(set_file).write_text(''.join(lines), encoding="utf-8")
+            self.color_label()
+
+    @staticmethod
+    def update_setting(update_res) -> None:
+        """
+        write off or on in file
+        Args:
+            update_res (int): argument that is passed contains 0 or 1
+        """
+        if update_res == 1:
+            lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+            lines[1] = 'off\n' 
+            Path(set_file).write_text(''.join(lines), encoding="utf-8")
+
+        else:
+            lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+            lines[1] = 'on\n' 
+            Path(set_file).write_text(''.join(lines), encoding="utf-8")
+
+    @staticmethod
+    def tooltip(tip) -> None:
+        """
+        write True or False in a file
+        Args:
+            tip (bool): argument that is passed contains True or False
+        """
+        if tip:
+            lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+            lines[5] = 'False\n' 
+            Path(set_file).write_text(''.join(lines), encoding="utf-8")
+
+        else:
+            lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+            lines[5] = 'True\n' 
+            Path(set_file).write_text(''.join(lines), encoding="utf-8")
+
+    def enable_check_box(self, _) -> None:
+        """
+        checkbox for enable autostart Tunnel
+        """
+        Create.files_for_autostart()
+        if self.l_box.size() != 0:
+            self.wg_autostart.configure(state="normal")
+            self.lb_rename.config(state="normal")
+            self.lb_rename.delete(0, tk.END)
+            self.btn_rename.config(state="normal")
+                
+    def delete(self) -> None:
+        """
+        delete Wireguard Tunnel
+        """
+        try:
+            self.select_tunnel = self.l_box.curselection()
+            select_tl = self.l_box.get(self.select_tunnel[0])
+            with open(f"/tmp/tlecdcwg/{select_tl}.conf", "r+", encoding="utf-8") as file2:
+                key = Tunnel.con_to_dict(file2)
+                pre_key = key[3]
+            check_call(["nmcli", "connection", "delete", select_tl])
+            self.l_box.delete(self.select_tunnel[0])
+            with open(set_file, "r", encoding="utf-8") as set_f6:
+                lines6 = set_f6.readlines()
+                if (select_tl == lines6[7].strip()
+                    and "off\n" not in lines6[7].strip()):
+                    lines6[7] = "off\n"
+                    with open(set_file, "w", encoding="utf-8") as set_f7:
+                        set_f7.writelines(lines6)
+                    self.selected_option.set(0)
+                    self.autoconnect_var.set(_("no Autoconnect"))
+            is_encrypt = Path.home() / f".config/wire_py/{select_tl}.dat"
+            if is_encrypt.is_file():
+                Path.unlink(f"{Path.home()}/.config/wire_py/{select_tl}.dat")
+            Path.unlink(f"/tmp/tlecdcwg/{select_tl}.conf")
+            with open(keys, "r", encoding="utf-8") as readfile:
+                with open(f"{Path.home()}/.config/wire_py/keys2", "w", encoding="utf-8") as writefile:
+                    for line in readfile:
+                        if pre_key not in line.strip("\n"):
+                            writefile.write(line)
+            file_one = Path(f"{Path.home()}/.config/wire_py/keys2")
+            file_two = file_one.with_name("keys")
+            file_one.replace(file_two)
+            self.wg_autostart.configure(state="disabled")
+
+            # for disabling checkbox when Listbox empty
+            if self.l_box.size() == 0:
+                self.wg_autostart.configure(state="disabled")
+                self.lb_rename.configure(state="disabled")
+                Tooltip(self.wg_autostart, _("You must have at least one\ntunnel in the list,to use the autostart")
+                        , tips)
+
+                Tooltip(self.btn_exp, _("No Tunnels in List for Export"), tips)
+                Tooltip(self.btn_stst, _("No tunnels to start in the list"), tips)
+                Tooltip(self.lb_rename, _("To rename a tunnel, at least one must be in the list"), tips, )
+                self.lb_rename.insert(0, _("Max. 12 characters!"))
+
+            if self.a != "" and self.a == select_tl:
+                self.str_var.set(value="")
+                self.start()
+                self.l_box.update()
+
+                self.reset_fields()
+
+        except IndexError:
+
+            if self.l_box.size() != 0:
+
+                LxTools.msg_window(img_w, img_i2, sl, pstl)
+
+            else:
+
+                LxTools.msg_window(img_w, img_i2, sl, pfit)
+
+    def tl_rename(self) -> None:
+        """
+        method to rename a tunnel
+        """
+        special_characters = ["\\", "/", "{", "}", " "]
+
+        if len(self.lb_rename.get()) > 12:
+
+            LxTools.msg_window(img_w, img_i2, rnp, _("The new name may contain only 12 characters"))
+
+        elif len(self.lb_rename.get()) == 0:
+
+            LxTools.msg_window(img_w, img_i2, rnp, _("At least one character must be entered"))
+
+        elif any(ch in special_characters for ch in self.lb_rename.get()):
+
+            msg_t = _("No valid sign. These must not be used.\nBlank, Slash, Backslash and { }\n")
+            LxTools.msg_window(img_w, img_i2, rnp, msg_t)
+
+        else:
+
+            try:
+                self.select_tunnel = self.l_box.curselection()
+                select_tl = self.l_box.get(self.select_tunnel[0])
+
+                # nmcli connection modify old connection.id iphone
+                check_call(["nmcli", "connection", "modify", select_tl, "connection.id", self.lb_rename.get()])
+                source = Path(f"/tmp/tlecdcwg/{select_tl}.conf")
+                destination = source.with_name(f"{self.lb_rename.get()}.conf")
+                source.replace(destination)
+                Path.unlink(f"{Path.home()}/.config/wire_py/{select_tl}.dat")
+
+                self.l_box.delete(self.select_tunnel[0])
+                self.l_box.insert("end", self.lb_rename.get())
+                self.l_box.update()
+                new_a_connect = self.lb_rename.get()
+                self.lb_rename.delete(0, tk.END)
+                if self.a != "" and self.a == select_tl:
+                    self.a = Tunnel.active()
+                    self.str_var.set(value=self.a)
+                    with open(set_file, "r", encoding="utf-8") as set_f5:
+                        lines5 = set_f5.readlines()
+                    if select_tl == lines5[7].strip() and "off\n" not in lines5[7].strip():
+                        lines5[7] = new_a_connect
+                        with open(set_file, "w", encoding="utf-8") as theme_set5:
+                            theme_set5.writelines(lines5)
+                        self.autoconnect_var.set(value=new_a_connect)
+
+                Create.encrypt()
+
+            except IndexError:
+
+                LxTools.msg_window(img_w, img_i2, rnp, pstl)
+
+            except subprocess.CalledProcessError:
+                pass
+
+    def import_sl(self) -> None:
+        """
+        validity check of wireguard config files
+        """
         Create.dir_and_files()
 
         try:
@@ -566,84 +550,76 @@ class FrameWidgets(ttk.Frame):
                 read = file.read()
             path_split = filepath.split("/")
             path_split1 = path_split[-1]
-            self.a = Tunnel.active()
 
             if "PrivateKey = " in read and "PublicKey = " in read and "Endpoint =" in read:
                 with open(filepath, "r", encoding="utf-8") as file:
                     key = Tunnel.con_to_dict(file)
                     pre_key = key[3]
                     if len(pre_key) != 0:
-                        with open(f"{Path.home()}/.config/wire_py/keys", "r", encoding="utf-8") as readfile:
-                            p_key = readfile.readlines()
-                            if pre_key in p_key or f"{pre_key}\n" in p_key:
                     
-                                msg_t = _("Tunnel already available!\nPlease use another file for import")
-                                LxTools.msg_window(img_w2, img_i2, ie, msg_t)
+                        p_key = keys.read_text(encoding="utf-8")
+                        if pre_key in p_key or f"{pre_key}\n" in p_key:
 
-                            else:
+                            msg_t = _("Tunnel already available!\nPlease use another file for import")
+                            LxTools.msg_window(img_w2, img_i2, ie, msg_t)
 
-                                with open(f"{Path.home()}/.config/wire_py/keys", "a", encoding="utf-8") as keyfile:
-                                    keyfile.write(f"{pre_key}\r")
-                                    if len(path_split1) > 17:
-                                        p1 = shutil.copy(filepath, "/tmp/tlecdcwg/")
-                                        path_split = path_split1[len(path_split1) - 17:]
-                                        os.rename(p1, f"/tmp/tlecdcwg/{path_split}")
-                                        new_conf = f"/tmp/tlecdcwg/{path_split}"
-                                        if self.a != "":
-                                            check_call(["nmcli", "connection", "down", Tunnel.active()])
-                                            self.label_empty()
+                        else:
 
-                                        subprocess.check_output(["nmcli", "connection", "import", "type",
-                                                                 "wireguard", "file", new_conf], text=True)
+                            with open(keys, "a", encoding="utf-8") as keyfile:
+                                keyfile.write(f"{pre_key}\r")
+                                if len(path_split1) > 17:
+                                    p1 = shutil.copy(filepath, "/tmp/tlecdcwg/")
+                                    path_split = path_split1[len(path_split1) - 17:]
+                                    os.rename(p1, f"/tmp/tlecdcwg/{path_split}")
+                                    new_conf = f"/tmp/tlecdcwg/{path_split}"
+                                    if self.a != "":
+                                        check_call(["nmcli", "connection", "down", self.a])
+                                        self.reset_fields()
 
-                                        Create.encrypt()
+                                    subprocess.check_output(["nmcli", "connection", "import", "type",
+                                                                "wireguard", "file", new_conf], text=True)
 
-                                    else:
-                                        shutil.copy(filepath, "/tmp/tlecdcwg/")
-                                        if self.a != "":
-                                            check_call(["nmcli", "connection", "down", Tunnel.active()])
-                                            self.label_empty()
+                                    Create.encrypt()
 
-                                        subprocess.check_output(["nmcli", "connection", "import", "type",
-                                                                 "wireguard", "file", filepath], text=True)
+                                else:
+                                    shutil.copy(filepath, "/tmp/tlecdcwg/")
+                                    if self.a != "":
+                                        check_call(["nmcli", "connection", "down", self.a])
+                                        self.reset_fields()
 
-                                        Create.encrypt()
+                                    subprocess.check_output(["nmcli", "connection", "import", "type",
+                                                                "wireguard", "file", filepath], text=True)
 
-                                    self.str_var.set("")
-                                    self.a = Tunnel.active()
-                                    self.l_box.insert(0, self.a)
-                                    self.wg_autostart.configure(state="normal")
-                                    self.l_box.selection_clear(0, tk.END)
-                                    self.l_box.update()
-                                    self.l_box.selection_set(0)
+                                    Create.encrypt()
 
-                                    Tooltip(self.wg_autostart, _("To use the autostart, enable this Checkbox"), tips)
+                                self.str_var.set("")
+                                self.a = Tunnel.active()
+                                self.l_box.insert(0, self.a)
+                                self.wg_autostart.configure(state="normal")
+                                self.l_box.selection_clear(0, tk.END)
+                                self.l_box.update()
+                                self.l_box.selection_set(0)
 
-                                    # Tooltip(self.l_box, _("List of available tunnels"))
+                                Tooltip(self.wg_autostart, _("To use the autostart, enable this Checkbox"), tips)
 
-                                    Tooltip(self.btn_tr, _("Click to delete a Wireguard Tunnel\nSelect from the list!")
-                                            , tips,)
+                                # Tooltip(self.l_box, _("List of available tunnels"))
 
-                                    Tooltip(self.btn_exp, _("         Click to export all\nWireguard Tunnel to Zipfile")
-                                            , tips)
+                                Tooltip(self.btn_tr, _("Click to delete a Wireguard Tunnel\nSelect from the list!")
+                                        , tips,)
 
-                                    Tooltip(self.btn_rename, _("To rename a tunnel, you need to\nselect a tunnel from"
-                                                               " the list"), tips)
+                                Tooltip(self.btn_exp, _("         Click to export all\nWireguard Tunnel to Zipfile")
+                                        , tips)
 
-                                    self.lb_rename.insert(0, "Max. 12 characters!")
-                                    self.str_var = tk.StringVar()
-                                    self.str_var.set(self.a)
-                                    self.color_label()
-                                    self.stop()
-                                    wg_read = f"/tmp/tlecdcwg/{self.a}.conf"
-                                    with open(wg_read, "r", encoding="utf-8") as file_for_key:
-                                        data = Tunnel.con_to_dict(file_for_key)
+                                Tooltip(self.btn_rename, _("To rename a tunnel, you need to\nselect a tunnel from"
+                                                            " the list"), tips)
 
-                                    # Address Label
-                                    self.init_and_report(data)
-                                    self.show_data()
-                                    check_call(["nmcli", "con", "mod", self.a, "connection.autoconnect", "no"])
-                                    Path.chmod(wg_read, 0o600)
+                                self.lb_rename.insert(0, "Max. 12 characters!")
+                                self.str_var = tk.StringVar()
+                                self.str_var.set(self.a)
+                                self.color_label()
+                                self.stop()
+                                data = self.handle_tunnel_data(self.a)
+                                check_call(["nmcli", "con", "mod", self.a, "connection.autoconnect", "no"])
 
             if ("PrivateKey = " in read) and ("Endpoint = " in read):
                 pass
@@ -661,9 +637,25 @@ class FrameWidgets(ttk.Frame):
         except subprocess.CalledProcessError:
             print("Tunnel exist!")
 
-    def box_set(self):
+    def handle_tunnel_data(self, tunnel_name: str) -> tuple[str, str, str, str | None]:
+        """_summary_
+
+        Args:
+            tunnel_name (str): name of a tunnel
+
+        Returns:
+            tuple[str, str]: tuple with tunnel data
         """
-        This Method will display the autostart label which
+        wg_read = f"/tmp/tlecdcwg/{tunnel_name}.conf"
+        with open(wg_read, "r", encoding="utf-8") as file:
+            data = Tunnel.con_to_dict(file)
+            self.init_and_report(data)
+            self.show_data()
+            return data
+
+    def box_set(self) -> None:
+        """
+        This Method will display the autostarted label which
         Tunnel is automatically started regardless of the active tunnel.
         The selected tunnel is written into a file to read it after the start of the system.
         """
@@ -672,11 +664,9 @@ class FrameWidgets(ttk.Frame):
             select_tl = self.l_box.get(select_tunnel[0])
 
             if self.selected_option.get() == 0:
-                with open(set_file, "r", encoding="utf-8") as set_f3:
-                    lines3 = set_f3.readlines()
-                    lines3[7] = "off\n"
-                with open(set_file, "w", encoding="utf-8") as set_f3:
-                    set_f3.writelines(lines3)
+                lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+                lines[7] = 'off\n' 
+                Path(set_file).write_text(''.join(lines), encoding="utf-8")
 
                 tl = Tunnel.list()
 
@@ -684,31 +674,28 @@ class FrameWidgets(ttk.Frame):
                     self.wg_autostart.configure(state="disabled")
 
             if self.selected_option.get() >= 1:
-                with open(set_file, "r", encoding="utf-8") as set_f3:
-                    lines3 = set_f3.readlines()
-                    lines3[7] = select_tl
-                with open(set_file, "w", encoding="utf-8") as set_f3:
-                    set_f3.writelines(lines3)
+                lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
+                lines[7] = select_tl
+                Path(set_file).write_text(''.join(lines), encoding="utf-8")
 
         except IndexError:
             self.selected_option.set(1)
 
         self.on_off()
 
-    def on_off(self):
+    def on_off(self) -> None:
         """
         Here it is checked whether the path to the file is there, if not, it is created.
         Set (on), the selected tunnel is displayed in the label.
         At (off) the label is first emptied then filled with No Autoconnect
         """
-        with open(set_file, "r", encoding="utf-8") as set_f4:
-            lines4 = set_f4.readlines()
+        lines = Path(set_file).read_text(encoding="utf-8").splitlines(keepends=True)
 
-        if lines4[7] != "off\n":
-            print(f"{lines4[7]} starts automatically when the system starts.")
+        if lines[7] != "off\n":
+            print(f"{lines[7]} starts automatically when the system starts.")
             self.selected_option.set(1)
             self.autoconnect_var.set("")
-            self.auto_con = lines4[7]
+            self.auto_con = lines[7]
 
         else:
             self.selected_option.set(0)
@@ -722,12 +709,11 @@ class FrameWidgets(ttk.Frame):
         self.autoconnect.config(font=("Ubuntu", 11))
         self.autoconnect.grid(column=1, row=0, sticky="e", pady=19)
 
-    def init_and_report(self, data=None):
+    def init_and_report(self, data=None) -> None:
         """
         Displays the value address, DNS and peer in the labels
         or empty it again
         """
-
         # Address Label
         self.add = tk.StringVar()
         self.add.set(f"{_("Address:    ")}{data[0]}")
@@ -736,19 +722,18 @@ class FrameWidgets(ttk.Frame):
         self.enp = tk.StringVar()
         self.enp.set(f"{_("Endpoint:    ")}{data[2]}")
 
-    def label_empty(self):
+    def reset_fields(self) -> None:
         """
-        empty labels
+        reset data from labels
         """
-        self.add.set("")
-        self.DNS.set("")
-        self.enp.set("")
+        fields = [self.add, self.DNS, self.enp]
+        for field in fields:
+            field.set("")
 
-    def show_data(self):
+    def show_data(self) -> None:
         """
         shows data in the label
         """
-
         # Address Label
         self.address = ttk.Label(self.lb_frame, textvariable=self.add, foreground="#0071ff")
         self.address.grid(column=0, row=5, sticky="w", padx=10, pady=6)
@@ -764,20 +749,22 @@ class FrameWidgets(ttk.Frame):
         self.endpoint.grid(column=0, row=8, sticky="w", padx=10, pady=20)
         self.endpoint.config(font=("Ubuntu", 9))
 
-    def stop(self):
+    def stop(self) -> None:
         """
         Stop Button
         """
-        self.btn_stst = ttk.Button(self.lb_frame_btn_lbox, image=self.wg_vpn_stop, command=self.wg_switch, padding=0)
+        self.btn_stst = ttk.Button(self.lb_frame_btn_lbox, image=self.wg_vpn_stop, 
+                                   command=lambda: self.wg_switch("stop"), padding=0)
         self.btn_stst.grid(column=0, row=0, padx=5, pady=8)
 
         Tooltip(self.btn_stst, _("Click to stop selected Wireguard Tunnel"), tips)
 
-    def start(self):
+    def start(self) -> None:
         """
         Start Button
         """
-        self.btn_stst = ttk.Button(self.lb_frame_btn_lbox, image=self.wg_vpn_start, command=self.wg_switch, padding=0)
+        self.btn_stst = ttk.Button(self.lb_frame_btn_lbox, image=self.wg_vpn_start, 
+                                   command=lambda: self.wg_switch("start"), padding=0)
         self.btn_stst.grid(column=0, row=0, padx=5, pady=8)
 
         tl = Tunnel.list()
@@ -786,66 +773,36 @@ class FrameWidgets(ttk.Frame):
         else:
             Tooltip(self.btn_stst, _("Click to start selected Wireguard Tunnel"), tips)
 
-    def color_label(self):
+    def color_label(self) -> None:
         """
         View activ Tunnel in the color green or yellow
         """
+        lines = set_file.read_text()
+        if "light\n" in lines:
+            self.lb_tunnel = ttk.Label(self, textvariable=self.str_var, foreground="green")
 
-        with open(set_file, "r", encoding="utf-8") as read_file:
-            lines = read_file.readlines()
-            if "light\n" in lines:
-                self.lb_tunnel = ttk.Label(self, textvariable=self.str_var, foreground="green")
-
-            else:
-                self.lb_tunnel = ttk.Label(self, textvariable=self.str_var, foreground="yellow")
+        else:
+            self.lb_tunnel = ttk.Label(self, textvariable=self.str_var, foreground="yellow")
 
         self.lb_tunnel.config(font=("Ubuntu", 11, "bold"))
         self.lb_tunnel.grid(column=2, padx=10, row=1)
 
-    def wg_switch(self):
+    def wg_switch(self, event=None) -> None:
         """
-        switch Tunnel method change from labels and buttons
+        Deals with switching the VPN connection
         """
-        self.a = Tunnel.active()
         try:
             if self.a == "":
-
-                self.start()
                 self.select_tunnel = self.l_box.curselection()
                 select_tl = self.l_box.get(self.select_tunnel[0])
-                check_call(["nmcli", "connection", "up", select_tl])
-                wg_read = f"/tmp/tlecdcwg/{select_tl}.conf"
-                with open(wg_read, "r", encoding="utf-8") as file:
-                    data = Tunnel.con_to_dict(file)
+                self.handle_connection_state("start", select_tl)
 
-                # Address Label
-                self.init_and_report(data)
-                self.show_data()
+            else:
                 
-                # Button Start/Stop
-                self.stop()
-                self.a = Tunnel.active()
-                self.str_var = tk.StringVar()
-                self.str_var.set(self.a)
-                self.color_label()
+                data = self.handle_tunnel_data(self.a)
+                if data:
 
-            elif self.a != "":
-
-                # Button Start/Stop
-                self.stop()
-                check_call(["nmcli", "connection", "down", self.a])
-
-                # Button Start/Stop
-                self.start()
-                self.a = Tunnel.active()
-                self.str_var.set("")
-                self.color_label()
-
-                # Address Label
-                self.add.set("")
-                self.DNS.set("")
-                self.enp.set("")
-                self.show_data()
+                    self.handle_connection_state("stop")
 
         except IndexError:
 
@@ -857,6 +814,49 @@ class FrameWidgets(ttk.Frame):
 
                 LxTools.msg_window(img_w, img_i2, sl, pfit)
 
+    def handle_connection_state(self, action: str, tunnel_name: str = None) -> None:
+        """
+        central management for connection states
+
+        Args:
+            action (str): "start", "stop" or "toggle"
+            tunnel_name (str, optional): name of a tunnel for a start-option. defaults to None.
+        """
+        if action == "stop":
+            if self.a:
+                check_call(["nmcli", "connection", "down", self.a])
+                self.update_connection_display()
+                self.reset_fields()
+                self.start()
+
+        elif action == "start":
+            if tunnel_name or self.a:
+                target_tunnel = tunnel_name or self.a
+                check_call(["nmcli", "connection", "up", target_tunnel])
+                self.update_connection_display()
+                data = self.handle_tunnel_data(self.a)
+                self.init_and_report(data)
+                self.show_data()
+                self.color_label()
+                self.stop()
+
+        elif action == "toggle":
+            if self.a:
+                self.handle_connection_state("stop")
+            else:
+                self.handle_connection_state("start")
+
+    def update_connection_display(self) -> None:
+        """
+        Updated the display after connection changes
+        """
+        self.a = Tunnel.active()
+        if not hasattr(self, "str_var"):
+            self.str_var = tk.StringVar()
+        self.str_var.set(self.a)
+        self.color_label()
+        self.show_data()
+
 
 if __name__ == "__main__":
     window = Wirepy()