german translate update2

.gitignore

@@ -1,5 +1,6 @@
 debug.log
 .venv
+.venv.bak
 .idea
 .vscode
 __pycache__

Changelog

@@ -6,24 +6,71 @@ My standard System: Linux Mint 22 Cinnamon
  - os import in common_tools.py replaced by other methods
  - If Wire-Py already runs, prevent further start
  - for loops with lists replaced by List Comprehensions
+ - Replace Download Button with Lx Tools installer
+
+   ### Added
+02-07-2025
+
+- Complete code for faulty f" string configuration dur addicted and fixed
+
+- updater replace Downloadbutton with Lx Tools installer
+
+- remove logviewer icon 
+
+- add settings.png icon for update button
 
 
    ### Added
-13-04-0725
+27-06-2025
+  
+ - Header added for more modern desing
+
+ - Sizes adjust the frames and labels improve
+
+ - More modern desing for listbox, Address, Dns and Endpoint
+
+ - ui works now better with rename button
+
+ - add Image class for manage Images
+
+   ### Added
+23-06-2025
+
+ - all msg_window with MassageDialog replaced
+
+   ### Added
+14-06-2025
+
+ - replace msg_window with MassageDialog
+ - vpn stop icon corrected
+
+   ### Added
+07-06-2025
+
+ - ssl_decrypt now directly checks whether encrypted files are located in the specified directory. 
+ - This method has been removed from common_tools. The path has been adjusted ssl_decrypt likely 
+   had an incorrect path. No files were decrypted. This has been fixed. 
+ - Key generation has been removed from ssl_decrypt, as it is only needed in ssl_encrypt.
+ - Logviewer now in the settings menu. Moduls now as libs in share_libs.
+ - The Lx Tools installer is there to ensure that everything required for the selected app is installed.
+
+
+   ### Added
+13-04-20255
 
  - Installer update for Open Suse Tumbleweed and Leap
  - add symbolic link wirepy.py 
 
 
    ### Added
-09-04-0725
+09-04-2025
 
  - Installer now with query and remove
  - Icons merged
 
 
    ### Added
-07-04-0725
+07-04-2025
 
  - Installers will support other systems again
  - Installer is now finished clean with wrong password
@@ -46,12 +93,14 @@ My standard System: Linux Mint 22 Cinnamon
  - Tunnels are now read from the directory to view them in the list. 
    To display only own tunnels, and read errors are minimized.
 
+
   ### Added
 10-11-2024
 
  - Fix Checkbutton Autostart when first install Wire-Py
  - Update Translate Files
 
+
   ### Added
 10-11-2024
 

common_tools.py

@@ -1,858 +0,0 @@
-""" Classes Method and Functions for lx Apps """
-
-import os
-import shutil
-import signal
-import subprocess
-import sys
-import tkinter as tk
-from typing import Optional, Dict, Any, NoReturn, TextIO, Tuple, List
-import zipfile
-from datetime import datetime
-from pathlib import Path
-from subprocess import check_call, CompletedProcess
-from tkinter import ttk, Toplevel
-from wp_app_config import AppConfig, Msg
-import requests
-
-# Translate
-_ = AppConfig.setup_translations()
-
-
-class Create:
-    """
-    This class is for the creation of the folders and files
-    required by Wire-Py, as well as for decryption
-    the tunnel from the user's home directory
-    """
-
-    @staticmethod
-    def dir_and_files() -> None:
-        """
-        check and create folders and files if not present
-        """
-
-        pth: Path = Path.home() / ".config/wire_py"
-        pth.mkdir(parents=True, exist_ok=True)
-        sett: Path = Path.home() / ".config/wire_py/settings"
-        AppConfig.KEYS_FILE
-
-        if sett.exists():
-            pass
-
-        else:
-            sett.touch()
-            sett.write_text(
-                "[UPDATES]\non\n[THEME]\nlight\n[TOOLTIP]\nTrue\n[AUTOSTART ON]\noff\n"
-            )
-
-        if AppConfig.KEYS_FILE.exists():
-            pass
-
-        else:
-            AppConfig.KEYS_FILE.touch()
-
-    @staticmethod
-    def files_for_autostart() -> None:
-        """
-        check and create a file for auto start if not present and enable the service
-        """
-
-        pth2: Path = Path.home() / ".config/systemd/user"
-        pth2.mkdir(parents=True, exist_ok=True)
-        wg_ser: Path = Path.home() / ".config/systemd/user/wg_start.service"
-
-        if wg_ser.exists():
-            pass
-
-        else:
-            wg_ser.touch()
-            wg_ser.write_text(
-                "[Unit]\nDescription=Automatic Tunnel Start\nAfter=network-online.target\n\n[Service]\n"
-                "Type=oneshot\nExecStartPre=/bin/sleep 5\nExecStart=/usr/local/bin/start_wg.py\n[Install]"
-                "\nWantedBy=default.target"
-            )
-            check_call(["systemctl", "--user", "enable", "wg_start.service"])
-
-    @staticmethod
-    def make_dir() -> None:
-        """Folder Name "tlecdewg" = Tunnel Encrypt Decrypt Wireguard"""
-
-        if AppConfig.TEMP_DIR.exists():
-            pass
-        else:
-            AppConfig.TEMP_DIR.mkdir()
-
-    @staticmethod
-    def decrypt() -> None:
-        """
-        Starts SSL dencrypt
-        """
-        process: CompletedProcess[str] = subprocess.run(
-            ["pkexec", "/usr/local/bin/ssl_decrypt.py"],
-            stdout=subprocess.PIPE,
-            text=True,
-            check=True,
-        )
-        path: Path = Path.home() / ".config/wire_py/"
-        file_in_path: list[Path] = list(path.rglob("*.dat"))
-        if file_in_path:
-            if process.returncode == 0:
-                print("File successfully decrypted...")
-
-            else:
-                print(f"Error with the following code... {process.returncode}")
-        else:
-            print(_("Ready for import"))
-
-    @staticmethod
-    def encrypt() -> None:
-        """
-        Starts SSL encryption
-        """
-        process: CompletedProcess[str] = subprocess.run(
-            ["pkexec", "/usr/local/bin/ssl_encrypt.py"],
-            stdout=subprocess.PIPE,
-            text=True,
-            check=True,
-        )
-        print(process.stdout)
-        if process.returncode == 0:
-            print("All Files successfully encrypted...")
-        else:
-            print(f"Error with the following code... {process.returncode}")
-
-
-class LxTools(tk.Tk):
-    """
-    Class LinuxTools methods that can also be used for other apps
-    """
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
-    @staticmethod
-    def center_window_cross_platform(window, width, height):
-        """
-        Centers a window on the primary monitor in a way that works on both X11 and Wayland
-
-        Args:
-            window: The tkinter window to center
-            width: Window width
-            height: Window height
-        """
-        # Calculate the position before showing the window
-
-        # First attempt: Try to use GDK if available (works on both X11 and Wayland)
-        try:
-            import gi
-
-            gi.require_version("Gdk", "3.0")
-            from gi.repository import Gdk
-
-            display = Gdk.Display.get_default()
-            monitor = display.get_primary_monitor() or display.get_monitor(0)
-            geometry = monitor.get_geometry()
-            scale_factor = monitor.get_scale_factor()
-
-            # Calculate center position on primary monitor
-            x = geometry.x + (geometry.width - width // scale_factor) // 2
-            y = geometry.y + (geometry.height - height // scale_factor) // 2
-
-            # Set window geometry
-            window.geometry(f"{width}x{height}+{x}+{y}")
-            return
-        except (ImportError, AttributeError):
-            pass
-
-        # Second attempt: Try xrandr for X11
-        try:
-            import subprocess
-
-            output = subprocess.check_output(
-                ["xrandr", "--query"], universal_newlines=True
-            )
-
-            # Parse the output to find the primary monitor
-            primary_info = None
-            for line in output.splitlines():
-                if "primary" in line:
-                    parts = line.split()
-                    for part in parts:
-                        if "x" in part and "+" in part:
-                            primary_info = part
-                            break
-                    break
-
-            if primary_info:
-                # Parse the geometry: WIDTHxHEIGHT+X+Y
-                geometry = primary_info.split("+")
-                dimensions = geometry[0].split("x")
-                primary_width = int(dimensions[0])
-                primary_height = int(dimensions[1])
-                primary_x = int(geometry[1])
-                primary_y = int(geometry[2])
-
-                # Calculate center position on primary monitor
-                x = primary_x + (primary_width - width) // 2
-                y = primary_y + (primary_height - height) // 2
-
-                # Set window geometry
-                window.geometry(f"{width}x{height}+{x}+{y}")
-                return
-        except (subprocess.SubprocessError, ImportError, IndexError, ValueError):
-            pass
-
-        # Final fallback: Use standard Tkinter method
-        screen_width = window.winfo_screenwidth()
-        screen_height = window.winfo_screenheight()
-
-        # Try to make an educated guess for multi-monitor setups
-        # If screen width is much larger than height, assume multiple monitors side by side
-        if (
-            screen_width > screen_height * 1.8
-        ):  # Heuristic for detecting multiple monitors
-            # Assume primary monitor is on the left half
-            screen_width = screen_width // 2
-
-        x = (screen_width - width) // 2
-        y = (screen_height - height) // 2
-        window.geometry(f"{width}x{height}+{x}+{y}")
-
-    @staticmethod
-    def get_file_name(path: Path, i: int = 5) -> List[str]:
-        """
-        Recursively searches the specified path for files and returns a list of filenames,
-        with the last 'i' characters of each filename removed.
-
-        This method is useful for obtaining filenames without specific file extensions,
-        e.g., to remove '.conf' from Wireguard configuration files.
-
-        Args:
-            path (Path): The directory path to search
-            i (int, optional): Number of characters to remove from the end of each filename.
-                            Default is 5, which typically corresponds to the length of '.conf'.
-
-        Returns:
-            List[str]: A list of filenames without the last 'i' characters
-
-        Example:
-            If path contains files like 'tunnel1.conf', 'tunnel2.conf' and i=5,
-            the method returns ['tunnel1', 'tunnel2'].
-        """
-        lists_file = list(path.rglob("*"))
-        lists_file = [conf_file.name[:-i] for conf_file in lists_file]
-        return lists_file
-
-    @staticmethod
-    def get_username() -> str:
-        """
-        Returns the username of the logged-in user,
-        even if the script is running with root privileges.
-        """
-        try:
-            result = subprocess.run(
-                ["logname"],
-                stdout=subprocess.PIPE,
-                text=True,
-                check=True,
-            )
-            if result.returncode != 0:
-                exit(1)
-            else:
-                print(result.stdout.strip())
-                return result.stdout.strip()
-
-        except subprocess.CalledProcessError:
-            pass
-
-    @staticmethod
-    def clean_files(TEMP_DIR: Path = None, file: Path = None) -> None:
-        """
-        method that can be added after need to delete a folder and a file when quitting.
-        Args:
-            :param file: default None
-            :param AppConfig.TEMP_DIR: default None
-        """
-        if AppConfig.TEMP_DIR is not None:
-            shutil.rmtree(AppConfig.TEMP_DIR)
-        try:
-            if file is not None:
-                Path.unlink(file)
-
-        except FileNotFoundError:
-            pass
-
-    @staticmethod
-    def msg_window(
-        image_path: Path,
-        image_path2: Path,
-        w_title: str,
-        w_txt: str,
-        txt2: Optional[str] = None,
-        com: Optional[str] = None,
-    ) -> None:
-        """
-        Creates message windows
-
-        :argument AppConfig.IMAGE_PATHS["icon_info"] = Image for TK window which is displayed to the left of the text
-        :argument AppConfig.IMAGE_PATHS["icon_vpn"] = Image for Task Icon
-        :argument w_title = Windows Title
-        :argument w_txt = Text for Tk Window
-        :argument txt2 = Text for Button two
-        :argument com = function for Button command
-        """
-        msg: tk.Toplevel = tk.Toplevel()
-        msg.resizable(width=False, height=False)
-        msg.title(w_title)
-        msg.configure(pady=15, padx=15)
-
-        # Lade das erste Bild für das Fenster
-        try:
-            msg.img = tk.PhotoImage(file=image_path)
-            msg.i_window = tk.Label(msg, image=msg.img)
-        except Exception as e:
-            print(f"Fehler beim Laden des Fensterbildes: {e}")
-            msg.i_window = tk.Label(msg, text="Bild nicht gefunden")
-
-        label: tk.Label = tk.Label(msg, text=w_txt)
-        label.grid(column=1, row=0)
-
-        if txt2 is not None and com is not None:
-            label.config(font=("Ubuntu", 11), padx=15, justify="left")
-            msg.i_window.grid(column=0, row=0, sticky="nw")
-            button2: ttk.Button = ttk.Button(
-                msg, text=f"{txt2}", command=com, padding=4
-            )
-            button2.grid(column=0, row=1, sticky="e", columnspan=2)
-            button: ttk.Button = ttk.Button(
-                msg, text="OK", command=msg.destroy, padding=4
-            )
-            button.grid(column=0, row=1, sticky="w", columnspan=2)
-        else:
-            label.config(font=("Ubuntu", 11), padx=15)
-            msg.i_window.grid(column=0, row=0)
-            button: ttk.Button = ttk.Button(
-                msg, text="OK", command=msg.destroy, padding=4
-            )
-            button.grid(column=0, columnspan=2, row=1)
-
-        # Lade das Icon für das Fenster
-        try:
-            icon = tk.PhotoImage(file=image_path2)
-            msg.iconphoto(True, icon)
-        except Exception as e:
-            print(f"Fehler beim Laden des Fenstericons: {e}")
-
-        msg.columnconfigure(0, weight=1)
-        msg.rowconfigure(0, weight=1)
-        msg.winfo_toplevel()
-
-    @staticmethod
-    def sigi(file_path: Optional[Path] = None, file: Optional[Path] = None) -> None:
-        """
-        Function for cleanup after a program interruption
-
-        :param file: Optional - File to be deleted
-        :param file_path: Optional - Directory to be deleted
-        """
-
-        def signal_handler(signum: int, frame: Any) -> NoReturn:
-            """
-            Determines clear text names for signal numbers and handles signals
-
-            Args:
-                signum: The signal number
-                frame: The current stack frame
-
-            Returns:
-                NoReturn since the function either exits the program or continues execution
-            """
-
-            signals_to_names_dict: Dict[int, str] = dict(
-                (getattr(signal, n), n)
-                for n in dir(signal)
-                if n.startswith("SIG") and "_" not in n
-            )
-
-            signal_name: str = signals_to_names_dict.get(
-                signum, f"Unnamed signal: {signum}"
-            )
-
-            # End program for certain signals, report to others only reception
-            if signum in (signal.SIGINT, signal.SIGTERM):
-                exit_code: int = 1
-                print(
-                    f"\nSignal {signal_name} {signum} received. => Aborting with exit code {exit_code}."
-                )
-                LxTools.clean_files(file_path, file)
-                print("Breakdown by user...")
-                sys.exit(exit_code)
-            else:
-                print(f"Signal {signum} received and ignored.")
-                LxTools.clean_files(file_path, file)
-                print("Process unexpectedly ended...")
-
-        # Register signal handlers for various signals
-        signal.signal(signal.SIGINT, signal_handler)
-        signal.signal(signal.SIGTERM, signal_handler)
-        signal.signal(signal.SIGHUP, signal_handler)
-
-
-class Tunnel:
-    """
-    Class of Methods for Wire-Py
-    """
-
-    @staticmethod
-    def parse_files_to_dictionary() -> Dict[str, List[str]]:
-        data = {}
-
-        if not AppConfig.TEMP_DIR.exists() or not AppConfig.TEMP_DIR.is_dir():
-            pass
-
-        # Get a list of all files in the directorys
-        files = [file for file in AppConfig.TEMP_DIR.iterdir() if file.is_file()]
-        if not files:
-            pass
-
-        # Search for the string in the files
-        for file in files:
-            try:
-                with open(file, "r") as f:
-                    content = f.read()
-                    # Hier parsen wir die relevanten Zeilen aus dem Inhalt
-                    address_line = next(
-                        line
-                        for line in content.splitlines()
-                        if line.startswith("Address")
-                    )
-                    dns_line = next(
-                        line for line in content.splitlines() if line.startswith("DNS")
-                    )
-                    endpoint_line = next(
-                        line
-                        for line in content.splitlines()
-                        if line.startswith("Endpoint")
-                    )
-
-                    # Extrahiere die Werte
-                    address = address_line.split("=")[1].strip()
-                    dns = dns_line.split("=")[1].strip()
-                    endpoint = endpoint_line.split("=")[1].strip()
-
-                    # Speichere im Dictionary
-                    data[file.stem] = {
-                        "Address": address,
-                        "DNS": dns,
-                        "Endpoint": endpoint,
-                    }
-            except Exception:
-                # Ignore errors and continue to the next file
-                continue
-
-        return data
-
-    @classmethod
-    def con_to_dict(cls, file: TextIO) -> Tuple[str, str, str, Optional[str]]:
-        """
-        Returns tuple of (address, dns, endpoint, pre_key)
-        """
-
-        dictlist: List[str] = []
-        for lines in file.readlines():
-            line_plit: List[str] = lines.split()
-            dictlist = dictlist + line_plit
-        dictlist.remove("[Interface]")
-        dictlist.remove("[Peer]")
-        for items in dictlist:
-            if items == "=":
-                dictlist.remove(items)
-            if items == "::/0":
-                dictlist.remove(items)
-
-        # Here is the beginning (Loop) of convert List to Dictionary
-        for _ in dictlist:
-            a: List[str] = [dictlist[0], dictlist[1]]
-            b: List[str] = [dictlist[2], dictlist[3]]
-            c: List[str] = [dictlist[4], dictlist[5]]
-            d: List[str] = [dictlist[6], dictlist[7]]
-            e: List[str] = [dictlist[8], dictlist[9]]
-            f: List[str] = [dictlist[10], dictlist[11]]
-            g: List[str] = [dictlist[12], dictlist[13]]
-            h: List[str] = [dictlist[14], dictlist[15]]
-            new_list: List[List[str]] = [a, b, c, d, e, f, g, h]
-            final_dict: Dict[str, str] = {}
-            for elements in new_list:
-                final_dict[elements[0]] = elements[1]
-
-            # end... result a Dictionary
-
-        address: str = final_dict["Address"]
-        dns: str = final_dict["DNS"]
-        if "," in dns:
-            dns = dns[:-1]
-        endpoint: str = final_dict["Endpoint"]
-        pre_key: Optional[str] = final_dict.get("PresharedKey")
-        if pre_key is None:
-            pre_key: Optional[str] = final_dict.get("PreSharedKey")
-        return address, dns, endpoint, pre_key
-
-    @staticmethod
-    def active() -> str:
-        """
-        Shows the Active Tunnel
-        """
-        active = (
-            os.popen('nmcli con show --active | grep -iPo "(.*)(wireguard)"')
-            .read()
-            .split()
-        )
-        if not active:
-            active = ""
-        else:
-            active = active[0]
-
-        return active
-
-    @staticmethod
-    def list() -> List[str]:
-        """
-        Returns a list of Wireguard tunnel names
-        """
-        AppConfig.TEMP_DIR: Path = Path("/tmp/tlecdcwg/")
-        wg_s: List[str] = os.listdir(AppConfig.TEMP_DIR)
-
-        return wg_s
-
-    @staticmethod
-    def export(
-        image_path: Path = None,
-        image_path2: Path = None,
-        image_path3: Path = None,
-        image_path4: Path = None,
-        title: Dict = None,
-        window_msg: Dict = None,
-    ) -> None:
-        """
-        This will export the tunnels.
-        A zipfile with the current date and time is created
-        in the user's home directory with the correct right
-        Args:
-            AppConfig.IMAGE_PATHS["icon_info"]: Image for TK window which is displayed to the left of the text
-            AppConfig.IMAGE_PATHS["icon_vpn"]: Image for Task Icon
-            AppConfig.IMAGE_PATHS["icon_error"]: Image for TK window which is displayed to the left of the text
-            AppConfig.IMAGE_PATHS["icon_msg"]: Image for Task Icon
-        """
-        now_time: datetime = datetime.now()
-        now_datetime: str = now_time.strftime("wg-exp-%m-%d-%Y-%H:%M")
-        tl: List[str] = Tunnel.list()
-
-        try:
-            if len(tl) != 0:
-                wg_tar: str = f"{Path.home()}/{now_datetime}"
-                shutil.copytree("/tmp/tlecdcwg/", "/tmp/wire_py", dirs_exist_ok=True)
-                source: Path = Path("/tmp/wire_py")
-                shutil.make_archive(wg_tar, "zip", source)
-                shutil.rmtree(source)
-                with zipfile.ZipFile(f"{wg_tar}.zip", "r") as zf:
-                    if len(zf.namelist()) != 0:
-
-                        LxTools.msg_window(
-                            AppConfig.IMAGE_PATHS["icon_info"],
-                            AppConfig.IMAGE_PATHS["icon_vpn"],
-                            Msg.STR["exp_succ"],
-                            Msg.STR["exp_in_home"],
-                        )
-
-                    else:
-
-                        LxTools.msg_window(
-                            AppConfig.IMAGE_PATHS["icon_error"],
-                            AppConfig.IMAGE_PATHS["icon_msg"],
-                            Msg.STR["exp_err"],
-                            Msg.STR["exp_try"],
-                        )
-
-            else:
-
-                LxTools.msg_window(
-                    AppConfig.IMAGE_PATHS["icon_info"],
-                    AppConfig.IMAGE_PATHS["icon_msg"],
-                    Msg.STR["sel_tl"],
-                    Msg.STR["tl_first"],
-                )
-
-        except TypeError:
-            pass
-
-
-# ConfigManager with caching
-class ConfigManager:
-    """
-    Universal class for managing configuration files with caching.
-    Can be reused in different projects.
-    """
-
-    _config = None
-    _config_file = None
-
-    @classmethod
-    def init(cls, config_file):
-        """Initial the Configmanager with the given config file"""
-        cls._config_file = config_file
-        cls._config = None  # Reset the cache
-
-    @classmethod
-    def load(cls):
-        """Load the config file and return the config as dict"""
-        if not cls._config:
-            try:
-                lines = Path(cls._config_file).read_text(encoding="utf-8").splitlines()
-                cls._config = {
-                    "updates": lines[1].strip(),
-                    "theme": lines[3].strip(),
-                    "tooltips": lines[5].strip()
-                    == "True",  # is converted here to boolean!!!
-                    "autostart": lines[7].strip() if len(lines) > 7 else "off",
-                }
-            except (IndexError, FileNotFoundError):
-                # DeDefault values in case of error
-                cls._config = {
-                    "updates": "on",
-                    "theme": "light",
-                    "tooltips": "True",  # Default Value as string !
-                    "autostart": "off",
-                }
-        return cls._config
-
-    @classmethod
-    def save(cls):
-        """Save the config to the config file"""
-        if cls._config:
-            lines = [
-                "# Configuration\n",
-                f"{cls._config['updates']}\n",
-                "# Theme\n",
-                f"{cls._config['theme']}\n",
-                "# Tooltips\n",
-                f"{str(cls._config['tooltips'])}\n",
-                "# Autostart\n",
-                f"{cls._config['autostart']}\n",
-            ]
-            Path(cls._config_file).write_text("".join(lines), encoding="utf-8")
-
-    @classmethod
-    def set(cls, key, value):
-        """Sets a configuration value and saves the change"""
-        cls.load()
-        cls._config[key] = value
-        cls.save()
-
-    @classmethod
-    def get(cls, key, default=None):
-        """Returns a configuration value"""
-        config = cls.load()
-        return config.get(key, default)
-
-
-class ThemeManager:
-    @staticmethod
-    def change_theme(root, theme_in_use, theme_name=None):
-        """Change application theme centrally"""
-        root.tk.call("set_theme", theme_in_use)
-        if theme_in_use == theme_name:
-            ConfigManager.set("theme", theme_in_use)
-
-
-class GiteaUpdate:
-    """
-    Calling download requests the download URL of the running script,
-    the taskbar image for the “Download OK” window, the taskbar image for the
-    “Download error” window and the variable res
-    """
-
-    @staticmethod
-    def api_down(update_api_url: str, version: str, update_setting: str = None) -> str:
-        """
-        Checks for updates via API
-
-        Args:
-            update_api_url: Update API URL
-            version: Current version
-            update_setting: Update setting from ConfigManager (on/off)
-
-        Returns:
-            New version or status message
-        """
-        # If updates are disabled, return immediately
-        if update_setting != "on":
-            return "False"
-
-        try:
-            response: requests.Response = requests.get(update_api_url, timeout=10)
-            response.raise_for_status()  # Raise exception for HTTP errors
-
-            response_data = response.json()
-            if not response_data:
-                return "No Updates"
-
-            latest_version = response_data[0].get("tag_name")
-            if not latest_version:
-                return "Invalid API Response"
-
-            # Compare versions (strip 'v. ' prefix if present)
-            current_version = version[3:] if version.startswith("v. ") else version
-
-            if current_version != latest_version:
-                return latest_version
-            else:
-                return "No Updates"
-
-        except requests.exceptions.RequestException:
-            return "No Internet Connection!"
-        except (ValueError, KeyError, IndexError):
-            return "Invalid API Response"
-
-    @staticmethod
-    def download(
-        urld: str,
-        res: str,
-        image_path: Path = None,
-        image_path2: Path = None,
-        image_path3: Path = None,
-        image_path4: Path = None,
-    ) -> None:
-        """
-        Downloads new version of wirepy
-
-        Args:
-            urld: Download URL
-            res: Result filename
-            AppConfig.IMAGE_PATHS["icon_info"]: Image for TK window which is displayed to the left of the text
-            AppConfig.IMAGE_PATHS["icon_vpn"]: Image for Task Icon
-            AppConfig.IMAGE_PATHS["icon_error"]: Image for TK window which is displayed to the left of the text
-            AppConfig.IMAGE_PATHS["icon_msg"]: Image for Task Icon
-        """
-        try:
-            to_down: str = f"wget -qP {Path.home()} {" "} {urld}"
-            result: int = subprocess.call(to_down, shell=True)
-            if result == 0:
-                shutil.chown(f"{Path.home()}/{res}.zip", 1000, 1000)
-
-                wt: str = _("Download Successful")
-                msg_t: str = _("Your zip file is in home directory")
-                LxTools.msg_window(
-                    AppConfig.IMAGE_PATHS["icon_info"],
-                    AppConfig.IMAGE_PATHS["icon_vpn"],
-                    wt,
-                    msg_t,
-                )
-
-            else:
-
-                wt: str = _("Download error")
-                msg_t: str = _("Download failed! Please try again")
-                LxTools.msg_window(
-                    AppConfig.IMAGE_PATHS["icon_error"],
-                    AppConfig.IMAGE_PATHS["icon_msg"],
-                    wt,
-                    msg_t,
-                )
-
-        except subprocess.CalledProcessError:
-
-            wt: str = _("Download error")
-            msg_t: str = _("Download failed! No internet connection!")
-            LxTools.msg_window(
-                AppConfig.IMAGE_PATHS["icon_error"],
-                AppConfig.IMAGE_PATHS["icon_msg"],
-                wt,
-                msg_t,
-            )
-
-
-class Tooltip:
-    """Class for Tooltip
-    from common_tools.py import Tooltip
-    example: Tooltip(label, "Show tooltip on label")
-    example: Tooltip(button, "Show tooltip on button")
-    example: Tooltip(widget, "Text", state_var=tk.BooleanVar())
-    example: Tooltip(widget, "Text", state_var=tk.BooleanVar(), x_offset=20, y_offset=10)
-
-    info: label and button are parent widgets.
-    NOTE: When using with state_var, pass the tk.BooleanVar object directly,
-    NOT its value. For example: use state_var=my_bool_var, NOT state_var=my_bool_var.get()
-    """
-
-    def __init__(
-        self,
-        widget: Any,
-        text: str,
-        state_var: Optional[tk.BooleanVar] = None,
-        x_offset: int = 65,
-        y_offset: int = 40,
-    ) -> None:
-        """Tooltip Class"""
-        self.widget: Any = widget
-        self.text: str = text
-        self.tooltip_window: Optional[Toplevel] = None
-        self.state_var = state_var
-        self.x_offset = x_offset
-        self.y_offset = y_offset
-
-        # Initial binding based on current state
-        self.update_bindings()
-
-        # Add trace to the state_var if provided
-        if self.state_var is not None:
-            self.state_var.trace_add("write", self.update_bindings)
-
-    def update_bindings(self, *args) -> None:
-        """Updates the bindings based on the current state"""
-        # Remove existing bindings first
-        self.widget.unbind("<Enter>")
-        self.widget.unbind("<Leave>")
-
-        # Add new bindings if tooltips are enabled
-        if self.state_var is None or self.state_var.get():
-            self.widget.bind("<Enter>", self.show_tooltip)
-            self.widget.bind("<Leave>", self.hide_tooltip)
-
-    def show_tooltip(self, event: Optional[Any] = None) -> None:
-        """Shows the tooltip"""
-        if self.tooltip_window or not self.text:
-            return
-
-        x: int
-        y: int
-        cx: int
-        cy: int
-
-        x, y, cx, cy = self.widget.bbox("insert")
-        x += self.widget.winfo_rootx() + self.x_offset
-        y += self.widget.winfo_rooty() + self.y_offset
-
-        self.tooltip_window = tw = tk.Toplevel(self.widget)
-        tw.wm_overrideredirect(True)
-        tw.wm_geometry(f"+{x}+{y}")
-
-        label: tk.Label = tk.Label(
-            tw,
-            text=self.text,
-            background="lightgreen",
-            foreground="black",
-            relief="solid",
-            borderwidth=1,
-            padx=5,
-            pady=5,
-        )
-        label.grid()
-
-        self.tooltip_window.after(2200, lambda: tw.destroy())
-
-    def hide_tooltip(self, event: Optional[Any] = None) -> None:
-        """Hides the tooltip"""
-        if self.tooltip_window:
-            self.tooltip_window.destroy()
-            self.tooltip_window = None

install

@@ -1,228 +0,0 @@
-#!/bin/bash
-NORMAL='\033[0m'
-GREEN='\033[1;32m'
-RED='\033[31;1;42m'
-BLUE='\033[30;1;34m'
-
-install_file_with(){
-  clear
-  mkdir -p ~/.config/wire_py && touch ~/.config/wire_py/keys && cp -u settings ~/.config/wire_py/ && \
-  mkdir -p ~/.config/systemd/user && cp -u wg_start.service ~/.config/systemd/user/ && \
-  systemctl --user enable wg_start.service >/dev/null 2>&1
-  sudo cp -f org.sslcrypt.policy /usr/share/polkit-1/actions/ 
-  if [ $? -ne 0 ]
-    then 
-      systemctl --user disable wg_start.service
-      rm -r ~/.config/wire_py && rm -r ~/.config/systemd
-      exit 0
-  else 
-    sudo apt install python3-tk && \
-    sudo cp -fv wirepy.py start_wg.py wp_app_config.py common_tools.py ssl_encrypt.py ssl_decrypt.py /usr/local/bin/ && \
-    sudo cp -uR lx-icons /usr/share/icons/ &&  sudo cp -uR TK-Themes /usr/share/ && \
-    sudo cp -u languages/de/*.mo /usr/share/locale/de/LC_MESSAGES/ && \
-    sudo cp -fv Wire-Py.desktop /usr/share/applications/ && \
-    sudo ln -sf /usr/local/bin/wirepy.py /usr/local/bin/wirepy
-    sudo mkdir -p /usr/local/etc/ssl
-    if [ ! -f /usr/local/etc/ssl/pwgk.pem ]
-      then
-        sudo openssl genrsa -out /usr/local/etc/ssl/pwgk.pem 4096
-    fi
-  fi  
-  }
-
-install_arch_d(){
-  clear
-  mkdir -p ~/.config/wire_py && touch ~/.config/wire_py/keys && cp -u settings ~/.config/wire_py/ && \
-  mkdir -p ~/.config/systemd/user && cp -u wg_start.service ~/.config/systemd/user/ && \
-  systemctl --user enable wg_start.service >/dev/null 2>&1
-  sudo cp -f org.sslcrypt.policy /usr/share/polkit-1/actions/
-  if [ $? -ne 0 ]
-    then 
-        systemctl --user disable wg_start.service
-        rm -r ~/.config/wire_py && rm -r ~/.config/systemd
-        exit 0
-  else 
-    sudo pacman -S --noconfirm tk python3 python-requests && \
-    sudo cp -fv wirepy.py start_wg.py wp_app_config.py common_tools.py ssl_encrypt.py ssl_decrypt.py /usr/local/bin/ && \
-    sudo cp -uR lx-icons /usr/share/icons/ &&  sudo cp -uR TK-Themes /usr/share/ && \
-    sudo cp -u languages/de/*.mo /usr/share/locale/de/LC_MESSAGES/ && \
-    sudo cp -fv Wire-Py.desktop /usr/share/applications/ && \
-    sudo ln -sf /usr/local/bin/wirepy.py /usr/local/bin/wirepy 
-    sudo mkdir -p /usr/local/etc/ssl
-    if [ ! -f /usr/local/etc/ssl/pwgk.pem ]
-      then
-        sudo openssl genrsa -out /usr/local/etc/ssl/pwgk.pem 4096
-    fi   
-   
-  fi 
-  }
-
-install(){
-  if grep -i 'debian' /etc/os-release > /dev/null 2>&1
-    then
-      groups > /tmp/isgroup
-      if grep 'sudo' /tmp/isgroup
-        then
-          install_file_with
-      else
-        echo -e "$BLUE"The installer found that they are not in the group sudo.""
-        echo -e "with "$RED"su -"$BLUE" "they can enter the root shell in which they then""
-        echo -e "enter "$GREEN""usermod -aG sudo $USER.""$BLUE""
-        echo -e ""after logging in from the system, they can then run Wire-Py install again." $NORMAL"
-        read -n 1 -s -r -p $"Press Enter to exit"
-        clear
-        exit 0
-
-      fi
-
-  elif grep -i 'mint\|ubuntu\|pop|' /etc/os-release > /dev/null 2>&1
-    then
-        install_file_with
-
-  elif grep -i 'arch' /etc/os-release > /dev/null 2>&1
-    then
-      groups > /tmp/isgroup
-      clear
-      if grep 'wheel' /tmp/isgroup
-        then
-            install_arch_d
-      else
-          echo "The installer found that they are not in the group sudo."
-          echo "The sudoers file must be edited with"
-          echo -e "$RED""su -""$NORMAL"
-          echo -e "$GREEN"""EDITOR=nano visudo"""$NORMAL"
-          echo "Find the line:"
-          echo "## Uncomment to allow members of group wheel to execute any command"
-          echo "remove '#' on  # %wheel ALL=(ALL) ALL and save the file"
-          echo -e "then enter "$GREEN"gpasswd -a $USER wheel.""$NORMAL"
-          echo "after logging in from the system, they can then run Wire-Py install again."
-          read -n 1 -s -r -p $"Press Enter to exit"
-          clear
-          exit 0
-
-      fi
-
-  elif grep -i '|manjaro\|garuda\|endeavour|' /etc/os-release > /dev/null 2>&1
-      then
-          install_arch_d
-
-  elif grep -i 'fedora' /etc/os-release > /dev/null 2>&1
-    then
-      clear
-      mkdir -p ~/.config/wire_py && touch ~/.config/wire_py/keys && cp -u settings ~/.config/wire_py/ && \
-      mkdir -p ~/.config/systemd/user && cp -u wg_start.service ~/.config/systemd/user/ && \
-      systemctl --user enable wg_start.service >/dev/null 2>&1
-      sudo cp -f org.sslcrypt.policy /usr/share/polkit-1/actions/
-      if [ $? -ne 0 ]
-        then 
-            systemctl --user disable wg_start.service
-            rm -r ~/.config/wire_py && rm -r ~/.config/systemd
-            exit 0
-      else
-        sudo dnf install python3-tkinter -y
-        sudo cp -fv wirepy.py start_wg.py wp_app_config.py common_tools.py ssl_encrypt.py ssl_decrypt.py /usr/local/bin/ && \
-        sudo cp -uR lx-icons /usr/share/icons/ &&  sudo cp -uR TK-Themes /usr/share/ && \
-        sudo cp -u languages/de/*.mo /usr/share/locale/de/LC_MESSAGES/ && \
-        sudo cp -fv Wire-Py.desktop /usr/share/applications/  && \
-        sudo ln -sf /usr/local/bin/wirepy.py /usr/local/bin/wirepy
-        sudo mkdir -p /usr/local/etc/ssl
-        if [ ! -f /usr/local/etc/ssl/pwgk.pem ]
-          then
-            sudo openssl genrsa -out /usr/local/etc/ssl/pwgk.pem 4096
-        fi
-
-      fi
-  elif grep -i 'suse' /etc/os-release > /dev/null 2>&1
-    then
-      clear
-      mkdir -p ~/.config/wire_py && touch ~/.config/wire_py/keys && cp -u settings ~/.config/wire_py/ && \
-      mkdir -p ~/.config/systemd/user && cp -u wg_start.service ~/.config/systemd/user/ && \
-      systemctl --user enable wg_start.service >/dev/null 2>&1
-      sudo cp -f org.sslcrypt.policy /usr/share/polkit-1/actions/
-      if [ $? -ne 0 ]
-        then 
-          systemctl --user disable wg_start.service
-          rm -r ~/.config/wire_py && rm -r ~/.config/systemd
-          exit 0
-      else 
-        sudo cp -fv wirepy.py start_wg.py wp_app_config.py common_tools.py ssl_encrypt.py ssl_decrypt.py /usr/local/bin/ && \
-        sudo cp -uR lx-icons /usr/share/icons/ &&  sudo cp -uR TK-Themes /usr/share/ && \
-        sudo cp -u languages/de/*.mo /usr/share/locale/de/LC_MESSAGES/ && \
-        sudo cp -fv Wire-Py.desktop /usr/share/applications/ && \
-        sudo ln -sf /usr/local/bin/wirepy.py /usr/local/bin/wirepy 
-        sudo mkdir -p /usr/local/etc/ssl
-        if [ ! -f /usr/local/etc/ssl/pwgk.pem ]
-          then
-            sudo openssl genrsa -out /usr/local/etc/ssl/pwgk.pem 4096
-        fi
-        if grep -i 'Tumbleweed' /etc/os-release > /dev/null 2>&1
-          then
-            sudo zypper install python313-tk
-        else
-          sudo zypper install python36-tk
-        fi
-              
-      fi
-      
-  else
-      clear
-      echo $"Your System could not be determined."
-      echo
-      read -n 1 -s -r -p $"Press Enter to exit"
-      clear
-      exit 0
-
-  fi
-  #clear
-  read -n 1 -s -r -p $"Press Enter to exit"
-  clear
-
-  }
-
-remove(){
-    sudo rm -f /usr/local/bin/wirepy /usr/local/bin/wirepy.py /usr/local/bin/start_wg.py \
-    /usr/local/bin/wp_app_config.py common_tools.py /usr/local/bin/ssl_encrypt.py /usr/local/bin/ssl_decrypt.py 
-    if [ $? -ne 0 ]
-      then
-        exit 0
-    else 
-      systemctl --user disable wg_start.service
-      rm -r ~/.config/wire_py && rm -r ~/.config/systemd
-      sudo rm /usr/share/applications/Wire-Py.desktop
-      sudo rm /usr/share/locale/de/LC_MESSAGES/languages/de/wirepy.mo
-      sudo rm -r /usr/local/etc/ssl
-      which syncpy >/dev/null
-      if [ $? -ne 0 ]
-        then 
-          sudo rm -r /usr/share/icons/lx-icons &&  sudo rm -r /usr/share/TK-Themes  
-
-      fi
-
-      echo
-      read -p "Press Enter to exit..."
-
-    fi
-
-  }
-
-which wirepy >/dev/null
-if [ $? -eq 0 ]
-    then
-        echo "Do you want to update/reinstall or uninstall wirepy?"
-        echo
-        echo "Update/reinstall: press y, uninstall press r"
-        echo
-        read -n 1 -s -r -p "Cancel with any other key..."  result
-        case $result in
-            [y]* ) clear; install; exit;;
-            [Y]* ) clear; install; exit;;
-            [j]* ) clear; install; exit;;
-            [J]* ) clear; install; exit;;
-            [r]* ) clear; remove; exit;;
-            [R]* ) clear; remove; exit;;
-        esac
-        clear
-else
-  install       
-   
-fi        

match_found.py

@@ -0,0 +1,61 @@
+#!/usr/bin/python3
+
+import argparse
+from pathlib import Path
+
+
+directorys: list[str] = [
+    "/etc/netplan/",
+    "/etc/NetworkManager/system-connections/",
+    "/var/lib/NetworkManager/user-connections/",
+]
+
+
+def search_string_in_directory(
+    directories: list[str] = directorys,  # Use the predefined list as default
+    search_string: str = "",  # Default is empty string
+) -> bool:
+
+    if len(search_string) == 0:
+        return False
+
+    result = False
+    for directory in directories:
+        in_paths = Path(directory)
+        if not in_paths.exists() or not in_paths.is_dir():
+            continue
+
+        files = [file for file in in_paths.iterdir() if file.is_file()]
+        if not files:
+            continue
+
+        # Search for the string in each file
+        for file in files:
+            try:
+                with open(file, "r", errors="ignore") as f:
+                    for line in f:
+                        if search_string in line:
+                            result = True  # String found
+                            break
+                    if result:
+                        break  # No need to check further
+            except Exception:
+                continue  # Skip files that cause errors
+
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Script only for use to compare the private key in the"
+        "Network configurations to avoid errors with the network manager."
+    )
+    parser.add_argument("search_string", help="Search string")
+    args = parser.parse_args()
+
+    result = search_string_in_directory(search_string=args.search_string)
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

org.sslcrypt.policy

@@ -25,6 +25,7 @@ License along with this library.  If not, see
   <action id="org.ssl_encrypt">
     <defaults>
       <allow_any>auth_admin_keep</allow_any>
+      <allow_inactive>auth_admin_keep</allow_inactive>
       <allow_active>yes</allow_active>
     </defaults>
     <annotate key="org.freedesktop.policykit.exec.path">/usr/local/bin/ssl_encrypt.py</annotate>
@@ -37,6 +38,14 @@ License along with this library.  If not, see
       <allow_active>yes</allow_active>
     </defaults>
     <annotate key="org.freedesktop.policykit.exec.path">/usr/local/bin/ssl_decrypt.py</annotate>
-    
+  </action>
+
+  <action id="org.match_found">
+    <defaults>
+      <allow_any>auth_admin_keep</allow_any>
+      <allow_inactive>auth_admin_keep</allow_inactive>
+      <allow_active>yes</allow_active>
+    </defaults>
+    <annotate key="org.freedesktop.policykit.exec.path">/usr/local/bin/match_found.py</annotate>
   </action>
 </policyconfig>

settings

@@ -1,8 +0,0 @@
-[UPDATES]
-on
-[THEME]
-light
-[TOOLTIP]
-True
-[AUTOSTART ON]
-off

ssl_decrypt.py

@@ -1,51 +1,42 @@
 #!/usr/bin/python3
 """ This Script decrypt Wireguard files for Wirepy users """
-
-import os
-import shutil
+import argparse
 from pathlib import Path
-from subprocess import check_call
-from wp_app_config import AppConfig
-import getpass
+import pwd
+import shutil
+from subprocess import CompletedProcess, run
+from shared_libs.wp_app_config import AppConfig
+from shared_libs.message import MessageDialog
 
-log_name: str = getpass.getuser()
-if log_name == "root":
 
-    from common_tools import LxTools
+parser = argparse.ArgumentParser()
+parser.add_argument("--user", required=True, help="Username of the target file system")
+args = parser.parse_args()
 
-    log_name: str = LxTools.get_username()
-    print("replacement method applied")
+_ = AppConfig.setup_translations()
+try:
+    # Retrieve UID and GID
+    user_info = pwd.getpwnam(args.user)
+    uid = user_info.pw_uid  # User ID (e.g., 1000)
+    gid = user_info.pw_gid  # Group ID (e.g., 1000)
+except KeyError:
+    MessageDialog(
+        "error", _(f"User '{args.user}' not found."), title="Error decrypt"
+    ).show()
+    exit(1)
 
-keyfile: Path = Path(f"/home/{log_name}/.config/wire_py/pbwgk.pem")
+crypted_tunnel: Path = Path(f"/home/{args.user}/.config/wire_py")
 
-if not keyfile.is_file():
+if len([str(file) for file in crypted_tunnel.glob("*.dat")]) == 0:
+    pass
+else:
+    crypted_tunnel = [str(file) for file in crypted_tunnel.glob("*.dat")]
 
-    check_call(
-        [
-            "openssl",
-            "rsa",
-            "-in",
-            AppConfig.SYSTEM_PATHS["pkey_path"],
-            "-out",
-            keyfile,
-            "-outform",
-            "PEM",
-            "-pubout",
-        ]
-    )
-    shutil.chown(keyfile, 1000, 1000)
+    for tunnel_path in crypted_tunnel:
 
-AppConfig.TEMP_DIR2 = f"/home/{log_name}/.config/wire_py/"
-detl: list[str] = os.listdir(AppConfig.TEMP_DIR2)
-os.chdir(AppConfig.TEMP_DIR2)
-detl.remove("keys")
-detl.remove("settings")
-if os.path.exists(f"{AppConfig.TEMP_DIR2}pbwgk.pem"):
-    detl.remove("pbwgk.pem")
-    for detunnels in detl:
-        tlname2 = f"{detunnels[:-4]}.conf"
-        extpath = f"{AppConfig.TEMP_DIR}/{tlname2}"
-        check_call(
+        base_name = Path(tunnel_path).stem
+
+        process: CompletedProcess[str] = run(
             [
                 "openssl",
                 "pkeyutl",
@@ -53,9 +44,22 @@ if os.path.exists(f"{AppConfig.TEMP_DIR2}pbwgk.pem"):
                 "-inkey",
                 AppConfig.SYSTEM_PATHS["pkey_path"],
                 "-in",
-                detunnels,
+                tunnel_path,  # full path to the file
                 "-out",
-                extpath,
-            ]
+                f"{AppConfig.TEMP_DIR}/{base_name}.conf",
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
         )
-        shutil.chown(extpath, 1000, 1000)
+        shutil.chown(f"{AppConfig.TEMP_DIR}/{base_name}.conf", uid, gid)
+
+        # Output from Openssl Error
+        if process.stderr:
+            MessageDialog(
+                "error",
+                _(
+                    f"{process.stderr} Error by [{tunnel_path}] Code: {process.returncode}"
+                ),
+                title="Error decrypt",
+            ).show()

ssl_encrypt.py

@@ -1,18 +1,36 @@
 #!/usr/bin/python3
 """ This Script encrypt Wireguardfiles for Wirepy users for more Security """
 
-import os
-import shutil
+import argparse
+import logging
 from pathlib import Path
-from subprocess import check_call
-from wp_app_config import AppConfig
-from common_tools import LxTools
+import pwd
+import shutil
+from subprocess import CompletedProcess, run
+from shared_libs.wp_app_config import AppConfig
+from shared_libs.common_tools import LogConfig
 
-keyfile: Path = AppConfig.PUBLICKEY
+parser = argparse.ArgumentParser()
+parser.add_argument("--user", required=True, help="Username of the target file system")
+args = parser.parse_args()
+
+LogConfig.logger(f"/home/{args.user}/.local/share/lxlogs/wirepy.log")
+try:
+    # Retrieve UID and GID
+    user_info = pwd.getpwnam(args.user)
+    uid = user_info.pw_uid  # User ID (e.g., 1000)
+    gid = user_info.pw_gid  # Group ID (e.g., 1000)
+except KeyError:
+    logging.error(f"User '{args.user}' not found.", exc_info=True)
+    exit(1)
+
+keyfile: Path = Path(f"/home/{args.user}/.config/wire_py/pbwgk.pem")
+
+target: Path = Path(f"/home/{args.user}/.config/wire_py/")
 
 if not keyfile.is_file():
 
-    check_call(
+    process: CompletedProcess[str] = run(
         [
             "openssl",
             "rsa",
@@ -23,56 +41,45 @@ if not keyfile.is_file():
             "-outform",
             "PEM",
             "-pubout",
-        ]
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
     )
-    shutil.chown(keyfile, 1000, 1000)
 
-    if AppConfig.TEMP_DIR.exists():
-        tl = LxTools.get_file_name(AppConfig.TEMP_DIR)
-        CPTH: str = f"{keyfile}"
-        CRYPTFILES: str = CPTH[:-9]
+    # Output from Openssl Error
+    if process.stderr:
+        logging.error(f"{process.stderr} Code: {process.returncode}", exc_info=True)
 
-        if keyfile.exists() and len(tl) != 0:
-            for tunnels in tl:
-                sourcetl: str = f"{AppConfig.TEMP_DIR}/{tunnels}"
-                tlname: str = f"{CRYPTFILES}{tunnels[:-5]}.dat"
-                check_call(
-                    [
-                        "openssl",
-                        "pkeyutl",
-                        "-encrypt",
-                        "-inkey",
-                        keyfile,
-                        "-pubin",
-                        "-in",
-                        sourcetl,
-                        "-out",
-                        tlname,
-                    ]
-                )
+    if process.returncode == 0:
+        logging.info("Public key generated successfully.", exc_info=True)
 
-else:
+    shutil.chown(keyfile, uid, gid)
 
-    if AppConfig.TEMP_DIR.exists():
-        tl: list[str] = os.listdir(f"{AppConfig.TEMP_DIR}")
-        CPTH: str = f"{keyfile}"
-        CRYPTFILES: str = CPTH[:-9]
+# any() get True when directory is not empty
+if AppConfig.TEMP_DIR.exists() and any(AppConfig.TEMP_DIR.iterdir()):
+    clear_files = [str(file) for file in AppConfig.TEMP_DIR.glob("*.conf")]
 
-        if keyfile.exists() and len(tl) != 0:
-            for tunnels in tl:
-                sourcetl: str = f"{AppConfig.TEMP_DIR}/{tunnels}"
-                tlname: str = f"{CRYPTFILES}{tunnels[:-5]}.dat"
-                check_call(
-                    [
-                        "openssl",
-                        "pkeyutl",
-                        "-encrypt",
-                        "-inkey",
-                        keyfile,
-                        "-pubin",
-                        "-in",
-                        sourcetl,
-                        "-out",
-                        tlname,
-                    ]
-                )
+    for config_file in clear_files:
+        base_name = Path(config_file).stem
+        process: CompletedProcess[str] = run(
+            [
+                "openssl",
+                "pkeyutl",
+                "-encrypt",
+                "-inkey",
+                keyfile,
+                "-pubin",
+                "-in",
+                config_file,
+                "-out",
+                f"{target}/{base_name}.dat",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        # Output from Openssl Error
+        if process.stderr:
+            logging.error(process.stderr, exc_info=True)

start_wg.py

@@ -2,15 +2,23 @@
 """
  This script belongs to wirepy and is for the auto start of the tunnel
 """
+import logging
+from subprocess import CompletedProcess, run
+from shared_libs.wp_app_config import AppConfig
+from shared_libs.common_tools import ConfigManager, LogConfig
 
-from pathlib import Path
-from subprocess import check_call
+ConfigManager.init(AppConfig.SETTINGS_FILE)
+LogConfig.logger(ConfigManager.get("logfile"))
+if ConfigManager.get("autostart") != "off":
+    process: CompletedProcess[str] = run(
+        ["nmcli", "connection", "up", ConfigManager.get("autostart")],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    # Output from start_wg error
+    if process.stderr:
+        logging.error(process.stderr, exc_info=True)
 
-path_to_file = Path(Path.home() / ".config/wire_py/settings")
-
-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

tunnel.py

@@ -0,0 +1,220 @@
+#!/usr/bin/python3
+import logging
+import getpass
+import zipfile
+from datetime import datetime
+from pathlib import Path
+import shutil
+from subprocess import run, CompletedProcess
+import secrets
+from shared_libs.wp_app_config import AppConfig, Msg
+from shared_libs.common_tools import LxTools, CryptoUtil
+from shared_libs.message import MessageDialog
+
+# Translate
+_ = AppConfig.setup_translations()
+
+
+class Tunnel:
+    """
+    Class of Methods for Wire-Py
+    """
+
+    @staticmethod
+    def parse_files_to_dictionary(
+        directory: Path = None, filepath: str = None, content: str = None
+    ) -> tuple[dict, str] | dict | None:
+        data = {}
+
+        if filepath is not None:
+            filepath = Path(filepath)
+            try:
+                content = filepath.read_text()
+
+                # parse the content
+                address_line = next(
+                    line for line in content.splitlines() if line.startswith("Address")
+                )
+                dns_line = next(
+                    line for line in content.splitlines() if line.startswith("DNS")
+                )
+                endpoint_line = next(
+                    line for line in content.splitlines() if line.startswith("Endpoint")
+                )
+                private_key_line = next(
+                    line
+                    for line in content.splitlines()
+                    if line.startswith("PrivateKey")
+                )
+
+                content = secrets.token_bytes(len(content))
+
+                # extract the values
+                address = address_line.split("=")[1].strip()
+                dns = dns_line.split("=")[1].strip()
+                endpoint = endpoint_line.split("=")[1].strip()
+                private_key = private_key_line.split("=")[1].strip()
+
+                # Shorten the tunnel name to the maximum allowed length if it exceeds 12 characters.
+                original_stem = filepath.stem
+                truncated_stem = (
+                    original_stem[-12:] if len(original_stem) > 12 else original_stem
+                )
+
+                # save in the dictionary
+                data[truncated_stem] = {
+                    "Address": address,
+                    "DNS": dns,
+                    "Endpoint": endpoint,
+                    "PrivateKey": private_key,
+                }
+
+                content = secrets.token_bytes(len(content))
+
+            except StopIteration:
+                pass
+
+        elif directory is not None:
+
+            if not directory.exists() or not directory.is_dir():
+                logging.error(
+                    "Temp directory does not exist or is not a directory.",
+                    exc_info=True,
+                )
+                return None
+
+            # Get a list of all files in the directory
+            files = [file for file in AppConfig.TEMP_DIR.iterdir() if file.is_file()]
+
+            # Search for the string in the files
+            for file in files:
+                try:
+                    content = file.read_text()
+                    # parse the content
+                    address_line = next(
+                        line
+                        for line in content.splitlines()
+                        if line.startswith("Address")
+                    )
+                    dns_line = next(
+                        line for line in content.splitlines() if line.startswith("DNS")
+                    )
+                    endpoint_line = next(
+                        line
+                        for line in content.splitlines()
+                        if line.startswith("Endpoint")
+                    )
+
+                    # extract values
+                    address = address_line.split("=")[1].strip()
+                    dns = dns_line.split("=")[1].strip()
+                    endpoint = endpoint_line.split("=")[1].strip()
+
+                    # save values to dictionary
+                    data[file.stem] = {
+                        "Address": address,
+                        "DNS": dns,
+                        "Endpoint": endpoint,
+                    }
+
+                except Exception:
+                    # Ignore errors and continue to the next file
+                    continue
+            if content is not None:
+                content = secrets.token_bytes(len(content))
+        if filepath is not None:
+            return data, truncated_stem
+        else:
+            return data
+
+    @staticmethod
+    def get_active() -> str:
+        """
+        Shows the Active Tunnel
+        """
+        active = None
+        try:
+            process: CompletedProcess[str] = run(
+                ["nmcli", "-t", "-f", "NAME,TYPE", "connection", "show", "--active"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            active = next(
+                line.split(":")[0].strip()
+                for line in process.stdout.splitlines()
+                if line.endswith("wireguard")
+            )
+
+            if process.stderr and "error" in process.stderr.lower():
+                logging.error(f"Error output on nmcli: {process.stderr}")
+
+        except StopIteration:
+            active = None
+        except Exception as e:
+            logging.error(f"Error on nmcli: {e}")
+            active = None
+
+        return active if active is not None else ""
+
+    @staticmethod
+    def export() -> bool | None:
+        """
+        This will export the tunnels.
+        A zipfile with the current date and time is created
+        in the user's home directory with the correct right
+        """
+        now_time: datetime = datetime.now()
+        now_datetime: str = now_time.strftime("wg-exp-%m-%d-%Y-%H:%M")
+
+        try:
+            AppConfig.ensure_directories()
+            CryptoUtil.decrypt(getpass.getuser())
+            if len([file.name for file in AppConfig.TEMP_DIR.glob("*.conf")]) == 0:
+
+                MessageDialog("info", Msg.STR["tl_first"], title=Msg.STR["sel_tl"])
+
+                return False
+            else:
+                wg_tar: str = f"{AppConfig.BASE_DIR}/{now_datetime}"
+                try:
+                    shutil.make_archive(wg_tar, "zip", AppConfig.TEMP_DIR)
+                    with zipfile.ZipFile(f"{wg_tar}.zip", "r") as zf:
+                        if zf.namelist():
+
+                            MessageDialog(
+                                "info",
+                                Msg.STR["exp_in_home"],
+                                title=Msg.STR["exp_succ"],
+                            )
+
+                        else:
+                            logging.error(
+                                "There was a mistake at creating the Zip file. File is empty."
+                            )
+                            MessageDialog(
+                                "error", Msg.STR["exp_zip"], title=Msg.STR["exp_err"]
+                            )
+
+                            return False
+                        return True
+                except PermissionError:
+                    logging.error(
+                        f"Permission denied when creating archive in {wg_tar}"
+                    )
+                    return False
+
+        except zipfile.BadZipFile as e:
+            logging.error(f"Invalid ZIP file: {e}")
+            return False
+        except TypeError:
+            pass
+        except Exception as e:
+            logging.error(f"Export failed: {str(e)}")
+            MessageDialog("error", Msg.STR["exp_try"], title=Msg.STR["exp_err"])
+            return False
+
+        finally:
+            LxTools.clean_files(AppConfig.TEMP_DIR)
+            AppConfig.ensure_directories()

wg_start.service

@@ -1,10 +0,0 @@
-[Unit]
-Description=Automatic Tunnel Start
-After=network-online.target 
-
-[Service]
-Type=oneshot
-ExecStartPre=/bin/sleep 5
-ExecStart=/usr/local/bin/start_wg.py
-[Install]
-WantedBy=default.target

wp_app_config.py

@@ -1,14 +1,39 @@
 #!/usr/bin/python3
 """App configuration for Wire-Py"""
-
+import logging
 import gettext
 import locale
+import tkinter as tk
+import os
 from pathlib import Path
+from subprocess import CompletedProcess, run
 from typing import Dict, Any
 
 
 class AppConfig:
-    """Central configuration class for Wire-Py application"""
+    """Central configuration and system setup manager for the Wire-Py application.
+
+    This class serves as a singleton-like container for all global configuration data,
+    including paths, UI settings, localization, versioning, and system-specific resources.
+    It ensures that required directories, files, and services are created and configured
+    before the application starts. Additionally, it provides tools for managing translations,
+    default settings, and autostart functionality to maintain a consistent user experience.
+
+    Key Responsibilities:
+    - Centralizes all configuration values (paths, UI preferences, localization).
+    - Ensures required directories and files exist on startup.
+    - Handles translation setup via `gettext` for multilingual support.
+    - Manages default settings file generation.
+    - Configures autostart services using systemd for user-specific launch behavior.
+
+    This class is used globally across the application to access configuration data
+    consistently and perform system-level setup tasks.
+    """
+
+    # Logging
+    LOG_DIR = Path.home() / ".local/share/lxlogs"
+    Path(LOG_DIR).mkdir(parents=True, exist_ok=True)
+    LOG_FILE_PATH = LOG_DIR / "wirepy.log"
 
     # Localization
     APP_NAME: str = "wirepy"
@@ -18,50 +43,44 @@ class AppConfig:
     BASE_DIR: Path = Path.home()
     CONFIG_DIR: Path = BASE_DIR / ".config/wire_py"
     TEMP_DIR: Path = Path("/tmp/tlecdcwg")
-    USER_FILE: Path = Path("/tmp/.log_user")
     PUBLICKEY: Path = CONFIG_DIR / "pbwgk.pem"
 
     # Configuration files
     SETTINGS_FILE: Path = CONFIG_DIR / "settings"
-    KEYS_FILE: Path = CONFIG_DIR / "keys"
+    SYSTEMD_USER_FOLDER: Path = Path.home() / ".config/systemd/user"
     AUTOSTART_SERVICE: Path = Path.home() / ".config/systemd/user/wg_start.service"
+    DEFAULT_SETTINGS: Dict[str, str] = {
+        "# Configuration": "on",
+        "# Theme": "dark",
+        "# Tooltips": True,
+        "# Autostart": "off",
+        "# Logfile": LOG_FILE_PATH,
+    }
 
     # Updates
     # 1 = 1. Year, 09 = Month of the Year, 2924 = Day and Year of the Year
-    VERSION: str = "v. 2.04.1725"
+    VERSION: str = "v. 2.07.0225"
     UPDATE_URL: str = "https://git.ilunix.de/api/v1/repos/punix/Wire-Py/releases"
     DOWNLOAD_URL: str = "https://git.ilunix.de/punix/Wire-Py/archive"
 
     # UI configuration
     UI_CONFIG: Dict[str, Any] = {
-        "window_title": "Wire-Py",
-        "window_size": (600, 383),
+        "window_title": "",
+        "window_title2": "LogViewer",
+        "window_size": (590, 460),
         "font_family": "Ubuntu",
         "font_size": 11,
-        "resizable_window": (False, False),
+        "resizable_window": (True, True),
     }
 
     # System-dependent paths
-    SYSTEM_PATHS: Dict[str, str] = {
+    SYSTEM_PATHS: Dict[str, Path] = {
         "ssl_decrypt": "/usr/local/bin/ssl_decrypt.py",
         "ssl_encrypt": "/usr/local/bin/ssl_encrypt.py",
         "tcl_path": "/usr/share/TK-Themes",
         "pkey_path": "/usr/local/etc/ssl/pwgk.pem",
     }
 
-    # Images and icons paths
-    IMAGE_PATHS: Dict[str, str] = {
-        "icon_vpn": "/usr/share/icons/lx-icons/48/wg_vpn.png",
-        "icon_msg": "/usr/share/icons/lx-icons/48/wg_msg.png",
-        "icon_import": "/usr/share/icons/lx-icons/48/wg_import.png",
-        "icon_export": "/usr/share/icons/lx-icons/48/wg_export.png",
-        "icon_trash": "/usr/share/icons/lx-icons/48/wg_trash.png",
-        "icon_start": "/usr/share/icons/lx-icons/48/wg_vpn-start.png",
-        "icon_stop": "/usr/share/icons/lx-icons/48/wg_vpn-stop.png",
-        "icon_info": "/usr/share/icons/lx-icons/64/info.png",
-        "icon_error": "/usr/share/icons/lx-icons/64/error.png",
-    }
-
     @staticmethod
     def setup_translations() -> gettext.gettext:
         """
@@ -79,7 +98,8 @@ class AppConfig:
     @classmethod
     def ensure_directories(cls) -> None:
         """Ensures that all required directories exist"""
-        cls.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        if not cls.CONFIG_DIR.exists():
+            cls.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
         cls.TEMP_DIR.mkdir(parents=True, exist_ok=True)
 
     @classmethod
@@ -92,34 +112,111 @@ class AppConfig:
             cls.SETTINGS_FILE.write_text(content)
 
     @classmethod
-    def get_image_paths(cls) -> Dict[str, Path]:
-        """Returns paths to UI images"""
-        return {
-            "main_icon": cls.SYSTEM_PATHS["image_path"] / "48/wg_vpn.png",
-            "warning": cls.CONFIG_DIR / "images/warning.png",
-            "success": cls.CONFIG_DIR / "images/success.png",
-            "error": cls.CONFIG_DIR / "images/error.png",
-        }
+    def get_autostart_content(cls) -> None:
+        """Returns the content for an autostart service file"""
+        systemd_file: list[str] = [
+            "[Unit]",
+            "Description=Automatic Tunnel Start",
+            "After=network-online.target",
+            "",
+            "[Service]",
+            "Type=oneshot",
+            "ExecStartPre=/bin/sleep 5",
+            "ExecStart=/usr/local/bin/start_wg.py",
+            "",
+            "[Install]",
+            "WantedBy=default.target",
+        ]
+        if not cls.SYSTEMD_USER_FOLDER.exists():
+            cls.SYSTEMD_USER_FOLDER.mkdir(parents=True, exist_ok=True)
+
+        if not cls.AUTOSTART_SERVICE.is_file():
+
+            content = "\n".join([line for line in systemd_file])
+            cls.AUTOSTART_SERVICE.write_text(content)
+
+        process: CompletedProcess[str] = run(
+            ["systemctl", "--user", "enable", "wg_start.service"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if process.returncode == 0:
+            logging.info(process.stdout, exc_info=True)
+
+        if process.stderr:
+            logging.error(f"{process.stderr} Code: {process.returncode}", exc_info=True)
 
     @classmethod
-    def get_autostart_content(cls) -> str:
-        """Returns the content for the autostart service file"""
-
-        return """[Unit]Description=Automatic Tunnel Start
-After=network-online.target
-
-[Service]
-Type=oneshot
-ExecStartPre=/bin/sleep 5
-ExecStart=/usr/local/bin/start_wg.py
-[Install]
-WantedBy=default.target"""
+    def ensure_log(cls) -> None:
+        """Ensures that the log file exists"""
+        if not cls.LOG_FILE_PATH.exists():
+            cls.LOG_FILE_PATH.touch()
 
 
-# here is inizialize the class for translate strrings
+# here is initializing the class for translation strings
 _ = AppConfig.setup_translations()
 
 
+class Image:
+    def __init__(self):
+        self.images = {}
+
+    def load_image(self, image_key, fallback_paths=None) -> None | tk.PhotoImage:
+        """Load PNG image using tk.PhotoImage with fallback options"""
+        if image_key in self.images:
+            return self.images[image_key]
+
+        # Define image paths based on key
+        image_paths = {
+            "icon_header": [
+                "/usr/share/icons/lx-icons/32/wg_vpn.png",
+            ],
+            "icon_vpn": [
+                "/usr/share/icons/lx-icons/48/wg_vpn.png",
+            ],
+            "icon_start": [
+                "/usr/share/icons/lx-icons/48/wg_vpn-start.png",
+            ],
+            "icon_stop": [
+                "/usr/share/icons/lx-icons/48/wg_vpn-stop.png",
+            ],
+            "icon_import": [
+                "/usr/share/icons/lx-icons/48/wg_import.png",
+            ],
+            "icon_export": [
+                "/usr/share/icons/lx-icons/48/wg_export.png",
+            ],
+            "icon_trash": [
+                "/usr/share/icons/lx-icons/48/wg_trash.png",
+            ],
+            "update": [
+                "/usr/share/icons/lx-icons/16/settings.png",
+            ],
+        }
+
+        # Get paths to try
+        paths_to_try = image_paths.get(image_key, [])
+
+        # Add fallback paths if provided
+        if fallback_paths:
+            paths_to_try.extend(fallback_paths)
+
+        # Try to load image from paths
+        for path in paths_to_try:
+            try:
+                if os.path.exists(path):
+                    photo = tk.PhotoImage(file=path)
+                    self.images[image_key] = photo
+                    return photo
+            except tk.TclError as e:
+                print(f"Fail to load image {path}: {e}")
+                continue
+
+        # Return None if no image found
+        return None
+
+
 class Msg:
     """
     A utility class that provides centralized access to translated message strings.
@@ -143,6 +240,8 @@ class Msg:
 
     STR: Dict[str, str] = {
         # Strings for messages
+        "header_left_bottom": _("Simple GUI for Wireguard"),
+        "header_right_top": _("Wireguard VPN Manager"),
         "sel_tl": _("Select tunnel"),
         "ren_err": _("Renaming not possible"),
         "exp_succ": _("Export successful"),
@@ -150,11 +249,16 @@ class Msg:
         "imp_err": _("Import Error"),
         "exp_err": _("Export Error"),
         "exp_try": _("Export failed! Please try again"),
+        "exp_zip": _(
+            "The error occurs because the zipfile module encountered an issue.\n"
+            "Please verify that you have the latest version of WirePy installed.\n"
+            "You can also contact the WirePy developer team to resolve this issue quickly.\n"
+        ),
         "tl_first": _("Please first import tunnel"),
         "sel_list": _("Please select a tunnel from the list"),
         "sign_len": _("The new name may contain only 12 characters"),
         "zero_signs": _("At least one character must be entered"),
-        "false signs": _(
+        "false_signs": _(
             "No valid sign. These must not be used.\nBlank, Slash, Backslash and { }\n"
         ),
         "is_in_use": _("The tunnel is already in use"),
@@ -162,6 +266,9 @@ class Msg:
             "Oh... no valid Wireguard File!\nPlease select a valid Wireguard File"
         ),
         "tl_exist": _("Tunnel already available!\nPlease use another file for import"),
+        "invalid_base64": _(
+            "Invalid base64 format!\nPlease use a Config file with valid key."
+        ),
     }
     TTIP: Dict[str, str] = {
         # Strings for Tooltips