CTkDeb 0.7.0__py3-none-any.whl

ctkdeb/__init__.py

@@ -0,0 +1,2 @@
+from .packager import Packager
+from .main import show_supported_rpm_distros

ctkdeb/gui.py

@@ -0,0 +1,361 @@
+import customtkinter as ctk
+from tkinter import messagebox, filedialog, PhotoImage
+import os
+import sys
+import json
+from threading import Thread
+
+from . import packager
+
+PATH = os.path.dirname(os.path.realpath(__file__))
+
+SUPPORTED = {
+    "DEB": "deb",
+    "RPM (Fedora)": "fedora",
+    "RPM (Mageia)": "mageia",
+    "RPM (OpenMandriva)": "openmandriva"
+}
+
+class CTkDeb(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+
+        self.appearance_mode_var = ctk.StringVar(value="light")
+        self.update_appearance_mode()
+
+        self.title("CTkDeb")
+        self.geometry("500x600")
+
+        self.wm_iconbitmap()
+        iconpath = PhotoImage(file=os.path.join(PATH, "icon.png"))
+        self.iconphoto(False, iconpath)
+
+        self.title_font = ctk.CTkFont(size=18)
+
+        self.fields = {
+            "app": {
+                "title": "App",
+                "items": [
+                    {"id": "name", "label": "Name", "placeholder": "myapp"},
+                    {"id": "version", "label": "Version", "placeholder": "0.16.2"},
+                    {"id": "entryPoint", "label": "Entry point", "placeholder": "main.py"},
+                    {"id": "icon", "label": "Icon", "placeholder": "assets/icon.png"},
+                    {"id": "iconSize", "label": "Icon size", "placeholder": "512x512"},
+                    {"id": "pipDependencies", "label": "Pip dependencies", "placeholder": "somelib potatolib"}
+                ]
+            },
+            "desktopEntry": {
+                "title": "Desktop entry",
+                "items": [
+                    {"type": "button", "text": "Add field", "command": self.add_new_desktop_entry_field},
+                    {"id": "Name", "label": "Name", "placeholder": "MyApp"},
+                    {"id": "Comment", "label": "Comment", "placeholder": "A simple alarm clock app"}
+                ]
+            },
+            "documentationFiles": {
+                "title": "Documentation files (licenses, README.md etc.)",
+                "items": [
+                    {"type": "button", "text": "Add file", "command": self.add_new_doc_file}
+                ]
+            },
+            "excluded": {
+                "title": "Excluded files and folders",
+                "items": [
+                    {"type": "button", "text": "Add file or folder", "command": self.add_new_excluded}
+                ]
+            },
+            "deb": {
+                "title": "DEB-specific settings",
+                "items": [
+                    {"id": "section", "label": "Section", "placeholder": "graphics"},
+                    {"id": "depends", "label": "Depends", "placeholder": "somelib, potatolib"},
+                    {"id": "maintainer", "label": "Maintainer", "placeholder": "Ivan Ivanov <ivan_dev@example.com>"},
+                    {"id": "description", "label": "Description", "placeholder": "A simple alarm clock app"},
+                ]
+            },
+            "rpm": {
+                "title": "RPM-specific settings",
+                "items": [
+                    {"id": "summary", "label": "Summary", "placeholder": "A simple alarm clock app"},
+                    {"id": "license", "label": "License", "placeholder": "MIT and GPL-3.0-or-later"},
+                    {"id": "url", "label": "URL", "placeholder": "https://myapp.com"},
+                    {"id": "description", "label": "Description",
+                     "placeholder": "MyApp is a simple alarm clock app with a user-friendly interface."}
+                ]
+            },
+            "rpmRequires": {
+                "title": "RPM requires",
+                "items": [
+                    {"id": "fedora", "label": "Fedora", "placeholder": "somelib potatolib"},
+                    {"id": "mageia", "label": "Mageia", "placeholder": "libsome potato-library"},
+                    {"id": "openmandriva", "label": "OpenMandriva", "placeholder": "some-lib potatolib3"}
+                ]
+            }
+        }
+        self.entries = {}
+        self.desktop_entry_entries = {}
+        self.doc_entries = []
+        self.excluded_entries = []
+
+        self.build_interface()
+
+    def update_appearance_mode(self):
+        ctk.set_appearance_mode(self.appearance_mode_var.get())
+
+    def build_interface(self):
+        self.create_header()
+        self.create_cards()
+        self.create_footer()
+
+    def create_header(self):
+        header = ctk.CTkFrame(self)
+        header.pack(padx=5, pady=5, side=ctk.TOP, fill=ctk.X)
+
+        ctk.CTkLabel(header, text="CTkDeb", font=self.title_font).pack(padx=10, pady=10, side=ctk.LEFT)
+
+        appearance_switch = ctk.CTkSwitch(header, text="Dark", variable=self.appearance_mode_var,
+                                          offvalue="light", onvalue="dark", command=self.update_appearance_mode)
+        appearance_switch.pack(padx=10, pady=10, side=ctk.RIGHT)
+
+    def create_footer(self):
+        footer = ctk.CTkFrame(self)
+        footer.pack(padx=5, pady=5, side=ctk.BOTTOM, fill=ctk.X)
+
+        config_frame = ctk.CTkFrame(footer)
+        config_frame.pack(side=ctk.LEFT, fill=ctk.X, expand=True)
+
+        import_config_button = ctk.CTkButton(config_frame, text="Import config", command=self.import_config)
+        import_config_button.pack(padx=10, pady=10, fill=ctk.X, expand=True)
+
+        export_config_button = ctk.CTkButton(config_frame, text="Export config", command=self.export_config)
+        export_config_button.pack(padx=10, pady=10, fill=ctk.X, expand=True)
+
+        create_frame = ctk.CTkFrame(footer)
+        create_frame.pack(side=ctk.RIGHT, fill=ctk.X, expand=True)
+
+        self.create_optionmenu = ctk.CTkOptionMenu(create_frame, values=list(SUPPORTED.keys()),
+                                                   dynamic_resizing=False)
+        self.create_optionmenu.pack(padx=10, pady=10, fill=ctk.X, expand=True)
+
+        self.create_button = ctk.CTkButton(create_frame, text="CREATE", command=self.on_create_clicked)
+        self.create_button.pack(padx=10, pady=10, fill=ctk.X, expand=True)
+
+    def create_cards(self):
+        scrollable = ctk.CTkScrollableFrame(self, fg_color="transparent")
+        scrollable.pack(padx=5, fill=ctk.BOTH, expand=True)
+
+        for section, items in self.fields.items():
+            self.entries[section] = {}
+
+            card = ctk.CTkFrame(scrollable)
+            card.pack(padx=10, pady=10, fill=ctk.X)
+
+            card.grid_columnconfigure(1, weight=1)
+
+            if section == "desktopEntry":
+                self.desktop_entry_card = card
+            elif section == "documentationFiles":
+                self.docs_card = card
+            elif section == "excluded":
+                self.excluded_card = card
+
+            title = ctk.CTkLabel(card, text=items["title"], font=self.title_font)
+            title.grid(row=0, column=0, padx=10, pady=10, columnspan=2, sticky=ctk.W)
+
+            for row, widget in enumerate(items["items"], start=1):
+                self.create_widget(section, card, widget, row)
+
+    def create_widget(self, section: str, card: ctk.CTkEntry, widget: dict, row: int):
+        if widget.get("type") == "button":
+            button = ctk.CTkButton(card, text=widget["text"], command=widget["command"])
+            button.grid(row=row, column=0, padx=10, pady=(0, 10), columnspan=2, sticky=ctk.EW)
+        else:
+            if packager.REQUIRED_FIELDS.get(section) and widget["id"] in packager.REQUIRED_FIELDS.get(section):
+                characters = "*:"
+            else:
+                characters = ":"
+
+            entry = self.add_labeled_entry(card, widget["label"] + characters, widget["placeholder"], row)
+            self.entries[section][widget["id"]] = entry
+
+    def add_labeled_entry(
+        self,
+        card: ctk.CTkFrame,
+        label_text: str,
+        placeholder: str,
+        row: int,
+        entry_type: bool = False
+    ):
+        if entry_type:
+            label = ctk.CTkEntry(card, placeholder_text=label_text)
+        else:
+            label = ctk.CTkLabel(card, text=label_text)
+        label.grid(row=row, column=0, padx=10, pady=(0, 10), sticky=ctk.W)
+
+        entry = ctk.CTkEntry(card, placeholder_text=placeholder)
+        entry.grid(row=row, column=1, padx=10, pady=(0, 10), sticky=ctk.EW)
+
+        if entry_type:
+            return label, entry
+        else:
+            return entry
+
+    def add_new_desktop_entry_field(self) -> ctk.CTkEntry:
+        next_row = self.desktop_entry_card.grid_size()[1]
+
+        entry = self.add_labeled_entry(self.desktop_entry_card, "Categories", "Application;Utility;", next_row, True)
+
+        return entry
+
+    def add_new_doc_file(self):
+        self.add_new_resource(self.docs_card, "File:", "LICENSE", self.doc_entries)
+
+    def add_new_excluded(self):
+        self.add_new_resource(self.excluded_card, "Item:", ".git", self.excluded_entries)
+
+    def add_new_resource(self, card: ctk.CTkFrame, label: str, placeholder: str, entries_list: list):
+        next_row = card.grid_size()[1]
+
+        entry = self.add_labeled_entry(card, label, placeholder, next_row)
+        entries_list.append(entry)
+
+    def import_config(self):
+        file_path = filedialog.askopenfilename(
+            title="Import config",
+            filetypes=([("JSON", "*.json")]),
+            defaultextension=".json"
+        )
+        if not file_path:
+            return
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+
+        self.destroy_user_widgets()
+
+        # Regular fields
+        for section, entries in self.entries.items():
+            if section in config:
+                for field_id, entry in entries.items():
+                    if field_id in config[section]:
+                        self.entry_set_text(entry, config[section][field_id])
+
+        # Desktop entry
+        for key, value in config["desktopEntry"].items():
+            if key in self.entries["desktopEntry"]:
+                self.entry_set_text(self.entries["desktopEntry"][key], value)
+            else:
+                label, entry = self.add_new_desktop_entry_field()
+                self.entry_set_text(label, key)
+                self.entry_set_text(entry, value)
+
+        # Documentation files
+        for value in config["documentationFiles"]:
+            self.add_new_doc_file()
+            self.entry_set_text(self.doc_entries[-1], value)
+
+        # Excluded files and folders
+        if config.get("excluded"):
+            for value in config["excluded"]:
+                self.add_new_excluded()
+                self.entry_set_text(self.excluded_entries[-1], value)
+
+        messagebox.showinfo("Config imported", "Config successfully imported")
+
+    def get_config_dict(self) -> dict:
+        config = {}
+
+        # Regular fields
+        for section, entries in self.entries.items():
+            config[section] = {}
+            for field_id, entry in entries.items():
+                value = entry.get()
+                if value:
+                    config[section][field_id] = value
+
+        # Desktop entry
+        for child in self.desktop_entry_card.winfo_children():
+            info = child.grid_info()
+            row, col = info["row"], info["column"]
+
+            if col == 0 and isinstance(child, ctk.CTkEntry):
+                key = child.get()
+                if not key:
+                    continue
+
+                for other in self.desktop_entry_card.winfo_children():
+                    other_info = other.grid_info()
+                    if other_info["row"] == row and other_info["column"] == 1:
+                        config["desktopEntry"][key] = other.get()
+
+        config["documentationFiles"] = [entry.get() for entry in self.doc_entries if entry.get()]
+        config["excluded"] = [entry.get() for entry in self.excluded_entries if entry.get()]
+
+        return config
+
+    def export_config(self):
+        config = self.get_config_dict()
+
+        file_path = filedialog.asksaveasfilename(
+            title="Export config",
+            filetypes=([("JSON", "*.json")]),
+            defaultextension=".json",
+            initialfile="ctkdeb.json"
+        )
+        if file_path:
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(config, f, indent="\t", ensure_ascii=False)
+                messagebox.showinfo("Config exported", "Config successfully exported")
+
+    def entry_set_text(self, entry: ctk.CTkEntry, value: str):
+        entry.delete(0, ctk.END)
+        entry.insert(0, value)
+
+    def destroy_user_widgets(self):
+        # Desktop entry
+        for child in self.desktop_entry_card.winfo_children():
+            info = child.grid_info()
+            row, col = info["row"], info["column"]
+
+            if col == 0 and isinstance(child, ctk.CTkEntry):
+                for other in self.desktop_entry_card.winfo_children():
+                    if other.grid_info()["row"] == row:
+                        other.destroy()
+
+        # Documentation files
+        for entry in self.doc_entries:
+            entry.destroy()
+        self.doc_entries.clear()
+
+    def on_create_clicked(self):
+        self.progressbar = ctk.CTkProgressBar(self, mode="determinate")
+        self.progressbar.pack(padx=5, pady=5, fill=ctk.X)
+        self.progressbar.start()
+
+        self.create_button.configure(state="disabled")
+
+        thread = Thread(target=self.create_package)
+        thread.start()
+
+    def create_package(self):
+        value = self.create_optionmenu.get()
+        value_name = SUPPORTED[value]
+
+        config = self.get_config_dict()
+
+        p = packager.Packager(config)
+
+        if value_name == "deb":
+            p.create_deb()
+        elif value_name in packager.RPM_REQUIRES.keys():
+            p.create_rpm(value_name)
+
+        self.after(0, self.on_package_created, value)
+
+    def on_package_created(self, value):
+        self.progressbar.stop()
+        self.progressbar.destroy()
+
+        self.create_button.configure(state="normal")
+
+        messagebox.showinfo(f"{value} created", f"{value} successfully created")

ctkdeb/main.py

@@ -0,0 +1,45 @@
+from .packager import RPM_REQUIRES
+
+def cli():
+    import argparse
+    from .packager import Packager
+
+    parser = argparse.ArgumentParser(
+        prog="CTkDeb",
+        description="A tool for easily packaging CustomTkinter projects into DEB and RPM"
+    )
+    parser.add_argument("json", type=str, help="Path to the JSON config")
+    parser.add_argument("-c", "--create", required=True, choices=["deb"] + list(RPM_REQUIRES.keys()))
+    parser.add_argument("-pf", "--project-folder", type=str,
+                        help="Path to the project folder (if the command is not executed from it)")
+    parser.add_argument("-d", "--desktop-entry", type=str,
+                        help="Path to the custom desktop entry (or its text)")
+    parser.add_argument("-of", "--output-folder", type=str, help="Path to the output folder")
+
+    args = parser.parse_args()
+
+    packager = Packager(
+        args.json,
+        project_folder=args.project_folder,
+        desktop_entry=args.desktop_entry,
+        output_folder=args.output_folder
+    )
+
+    if args.create == "deb":
+        packager.create_deb()
+    elif args.create in RPM_REQUIRES.keys():
+        packager.create_rpm(args.create)
+
+def gui():
+    from .gui import CTkDeb
+
+    app = CTkDeb()
+    app.mainloop()
+
+def show_supported_rpm_distros():
+    print("Supported RPM distros:")
+    for distro in RPM_REQUIRES.keys():
+        print(f"- '{distro}'")
+
+if __name__ == "__main__":
+    cli()

ctkdeb/packager.py

@@ -0,0 +1,327 @@
+import json
+from pathlib import Path
+import shutil
+import tempfile
+import tarfile
+import subprocess
+
+REQUIRED_FIELDS = {
+    "app": ["name", "version", "entryPoint", "icon", "iconSize"],
+    "desktopEntry": ["Name"]
+}
+
+RPM_REQUIRES = {
+    "fedora": "python3 python3-tkinter",
+    "mageia": "python3 tkinter3",
+    "openmandriva": "python python-customtkinter"
+}
+
+def _pip_install_to_dir(target_dir: Path, dependencies: str):
+    packages = dependencies.split()
+
+    cmd = ["pip", "install", "--target", str(target_dir)] + packages
+    subprocess.run(cmd)
+
+    # Clean garbage
+    for p in target_dir.rglob("*.py[co]"):
+        p.unlink()
+    for p in target_dir.rglob("__pycache__"):
+        shutil.rmtree(p)
+
+class Packager:
+    def __init__(
+        self,
+        json_path: str | dict,
+        project_folder: str | None = None,
+        desktop_entry: str | None = None,
+        output_folder: str | None = None
+    ):
+        if isinstance(json_path, str):
+            with open(json_path, "r", encoding="utf-8") as f:
+                self.json = json.load(f)
+        elif isinstance(json_path, dict):
+            self.json = json_path
+        else:
+            raise TypeError("'json_path' can only be str or dict.")
+
+        self._check_required_fields()
+
+        if project_folder:
+            self.project_folder = Path(project_folder)
+        else:
+            self.project_folder = Path.cwd()
+
+        if desktop_entry:
+            try:
+                if Path(desktop_entry).exists():
+                    with open(desktop_entry, "r", encoding="utf-8") as f:
+                        self.desktop_entry = f.read()
+                else:
+                    self.desktop_entry = desktop_entry
+            except OSError:
+                self.desktop_entry = desktop_entry
+        else:
+            self.desktop_entry = self._create_desktop_entry()
+
+        if output_folder:
+            self.output_folder = output_folder
+        else:
+            self.output_folder = Path.cwd()
+
+    def _check_required_fields(self):
+        for section, fields in REQUIRED_FIELDS.items():
+            if section not in self.json:
+                raise ValueError(f"Section '{section}' is missing")
+
+            for field in fields:
+                if not self.json[section].get(field):
+                    raise ValueError(f"Field '{section}.{field}' is missing or empty")
+
+    def _create_desktop_entry(self) -> str:
+        desktop_entry_dict = {
+            "[Desktop Entry]": None,
+            "Type": "Application",
+            "Version": "1.0",
+            "Name": self.json["desktopEntry"]["Name"],
+            "Exec": f"python3 /opt/{self.project_folder.name}/{self.json['app']['entryPoint']} %f",
+            "Icon": self.json["app"]["name"],
+            "Terminal": "false"
+        }
+
+        for key, value in self.json["desktopEntry"].items():
+            desktop_entry_dict[key] = value
+
+        result_lines = []
+        for key, value in desktop_entry_dict.items():
+            if value is None:
+                result_lines.append(key) # for title
+            else:
+                result_lines.append(f"{key}={value}")
+
+        return "\n".join(result_lines)
+
+    def create_deb(self):
+        tmp_dir = tempfile.mkdtemp()
+
+        package_dir = Path(tmp_dir) / self.json["app"]["name"]
+        package_dir.mkdir()
+
+        share_dir = package_dir / "usr" / "share"
+        share_dir.mkdir(parents=True)
+
+        print("Copying app files...")
+
+        opt_dir = package_dir / "opt"
+        copy_path = opt_dir / self.project_folder.name
+
+        shutil.copytree(self.project_folder, copy_path)
+        self.delete_excluded_items(copy_path)
+
+        print("Copying the icon...")
+
+        apps_icons_dir = share_dir / "icons" / "hicolor" / self.json["app"]["iconSize"] / "apps"
+        apps_icons_dir.mkdir(parents=True)
+
+        shutil.copy(self.project_folder / self.json["app"]["icon"], apps_icons_dir / self._new_icon_name())
+
+        print("Creating the desktop entry...")
+
+        applications_dir = share_dir / "applications"
+        applications_dir.mkdir()
+
+        with open(applications_dir / (self.json["app"]["name"] + ".desktop"), "w", encoding="utf-8") as f:
+            f.write(self.desktop_entry)
+
+        print("Copying docs...")
+
+        app_doc_dir = share_dir / "doc" / self.json["app"]["name"]
+        app_doc_dir.mkdir(parents=True)
+
+        for f in self.json["documentationFiles"]:
+            shutil.copy(self.project_folder / f, app_doc_dir)
+
+        print("Install CustomTkinter and pip dependencies...")
+
+        dependencies = "customtkinter"
+        if self.json["app"].get("pipDependencies"):
+            dependencies += " " + self.json["app"]["pipDependencies"]
+
+        _pip_install_to_dir(self._pip_target_dir(opt_dir), dependencies)
+
+        print("Estimating package dir size...")
+
+        size_bytes = sum(f.stat().st_size for f in package_dir.rglob("*") if f.is_file())
+        size_kb = size_bytes // 1024
+
+        print("Creating control file...")
+
+        debian_dir = package_dir / "DEBIAN"
+        debian_dir.mkdir()
+
+        depends = "python3, python3-tk"
+        if self.json["deb"].get("depends"):
+            depends += ", " + self.json["deb"]["depends"]
+
+        deb_control = f"""Package: {self.json['app']['name']}
+Version: {self.json['app']['version']}
+Section: {self.json['deb'].get('section') or 'unknown'}
+Priority: optional
+Depends: {depends}
+Architecture: all
+Essential: no
+Installed-Size: {size_kb}
+Maintainer: {self.json['deb'].get('maintainer') or 'Unknown <unknown@example.com>'}
+Description: {self.json['deb'].get('description') or 'Packaged via CTkDeb'}
+"""
+
+        with open(debian_dir / "control", "w", encoding="utf-8") as f:
+            f.write(deb_control)
+
+        print("Creating DEB package...")
+
+        subprocess.run(["dpkg-deb", "--build", package_dir])
+
+        print("Moving DEB and removing tmp dir...")
+
+        shutil.move(Path(tmp_dir) / (self.json["app"]["name"] + ".deb"), self.output_folder)
+        shutil.rmtree(tmp_dir)
+
+        print("DEB successfully created!")
+
+    def create_rpm(self, distribution: str):
+        supported_distros = RPM_REQUIRES.keys()
+        if distribution not in supported_distros:
+            raise ValueError(f"Only {' '.join(supported_distros)} are supported.")
+
+        tmp_dir = tempfile.mkdtemp()
+
+        package_dir = Path(tmp_dir) / self.json["app"]["name"]
+        package_dir.mkdir()
+
+        print("Creating SPEC file...")
+
+        requires = RPM_REQUIRES[distribution]
+        if self.json["rpmRequires"].get(distribution):
+            requires += " " + self.json["rpmRequires"][distribution]
+
+        docs_files_names = [Path(f).name for f in self.json["documentationFiles"]]
+
+        spec = f"""Name: {self.json['app']['name']}
+Version: {self.json['app']['version']}
+Release: 1.{distribution}
+Summary: {self.json['rpm'].get('summary') or 'Packaged via CTkDeb'}
+License: {self.json['rpm'].get('license') or 'Unknown'}
+Source0: {self.json['app']['name']}.tar
+BuildArch: noarch
+URL: {self.json['rpm'].get('url') or 'https://example.com'}
+Requires: {requires}
+
+%description
+{self.json['rpm'].get('description') or 'This app is packaged via CTkDeb.'}
+
+%prep
+%setup -q -n {self.json['app']['name']}
+
+%install
+mkdir -p %{{buildroot}}/opt
+cp -r {self.project_folder.name} %{{buildroot}}/opt
+
+mkdir -p %{{buildroot}}/usr/share/icons/hicolor/{self.json['app']['iconSize']}/apps
+cp {self._new_icon_name()} %{{buildroot}}/usr/share/icons/hicolor/{self.json['app']['iconSize']}/apps
+
+mkdir -p %{{buildroot}}/usr/share/applications
+cp {self.json['app']['name']}.desktop %{{buildroot}}/usr/share/applications
+{f"""
+mkdir -p %{{buildroot}}/usr/share/doc/{self.json['app']['name']}
+cp {' '.join(docs_files_names)} %{{buildroot}}/usr/share/doc/{self.json['app']['name']}
+""" if docs_files_names else ''}
+%files
+/opt/{self.project_folder.name}
+/usr/share/icons/hicolor/{self.json['app']['iconSize']}/apps/{self._new_icon_name()}
+/usr/share/applications/{self.json['app']['name']}.desktop
+{''.join(f"/usr/share/doc/{self.json['app']['name']}/{f}\n" for f in docs_files_names)
+if docs_files_names else ''}"""
+
+        with open(package_dir / (self.json["app"]["name"] + ".spec"), "w", encoding="utf-8") as f:
+            f.write(spec)
+
+        print("Creating the desktop entry...")
+
+        with open(package_dir / (self.json["app"]["name"] + ".desktop"), "w", encoding="utf-8") as f:
+            f.write(self.desktop_entry)
+
+        print("Copying app files...")
+
+        copy_path = package_dir / self.project_folder.name
+
+        shutil.copytree(self.project_folder, copy_path)
+        self.delete_excluded_items(copy_path)
+
+        print("Copying the icon...")
+
+        shutil.copy(self.project_folder / self.json["app"]["icon"], package_dir / self._new_icon_name())
+
+        print("Copying docs...")
+
+        for f in self.json["documentationFiles"]:
+            shutil.copy(self.project_folder / f, package_dir)
+
+        print("Install CustomTkinter and pip dependencies...")
+
+        dependencies = []
+
+        if distribution != "openmandriva":
+            dependencies.append("customtkinter")
+
+        if self.json["app"].get("pipDependencies"):
+            dependencies.extend(self.json["app"]["pipDependencies"].split())
+
+        if dependencies:
+            _pip_install_to_dir(self._pip_target_dir(package_dir), " ".join(dependencies))
+
+        print("Creating tarball...")
+
+        tar_name = Path(tmp_dir) / (self.json["app"]["name"] + ".tar")
+
+        with tarfile.open(tar_name, "w") as f:
+            f.add(package_dir, arcname=self.json["app"]["name"])
+
+        print("Creating RPM package...")
+
+        subprocess.run(["rpmbuild", "-tb", tar_name, "--define", "_topdir " + tmp_dir])
+
+        print("Moving RPM and removing tmp dir...")
+
+        for f in (Path(tmp_dir) / "RPMS" / "noarch").glob("*.rpm"):
+            shutil.move(str(f), self.output_folder)
+
+        shutil.rmtree(tmp_dir)
+
+        print("RPM successfully created!")
+
+    def _new_icon_name(self) -> str:
+        icon_path = Path(self.json["app"]["icon"])
+        return self.json["app"]["name"] + icon_path.suffix
+
+    def _pip_target_dir(self, app_files_dir_parent: Path) -> Path:
+        entry_point = Path(self.json["app"]["entryPoint"])
+
+        if len(entry_point.parts) == 1:
+            d = app_files_dir_parent / self.project_folder.name
+        else:
+            d = app_files_dir_parent / self.project_folder.name / entry_point.parent
+
+        return d
+
+    def delete_excluded_items(self, path: Path):
+        if not self.json.get("excluded"):
+            return
+
+        for name in self.json["excluded"]:
+            target = path / name
+
+            if target.exists():
+                if target.is_file():
+                    target.unlink()
+                elif target.is_dir():
+                    shutil.rmtree(target)

ctkdeb-0.7.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: CTkDeb
+Version: 0.7.0
+Summary: A tool for easily packaging CustomTkinter projects into DEB and RPM
+Author: limafresh
+Maintainer: limafresh
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/limafresh/CTkDeb
+Project-URL: Documentation, https://github.com/limafresh/CTkDeb
+Project-URL: Repository, https://github.com/limafresh/CTkDeb.git
+Project-URL: Issues, https://github.com/limafresh/CTkDeb/issues
+Project-URL: Changelog, https://github.com/limafresh/CTkDeb/blob/main/CHANGELOG.md
+Keywords: gui,customtkinter,deb,rpm,linux,package
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: gui
+Requires-Dist: customtkinter; extra == "gui"
+Dynamic: license-file
+
+# CTkDeb
+
+![Static Badge](https://img.shields.io/badge/No-PyInstaller-blue?style=for-the-badge)
+![Static Badge](https://img.shields.io/badge/Simple-GUI-blue?style=for-the-badge)
+
+<p align="center">
+    <img src="https://raw.githubusercontent.com/limafresh/CTkDeb/main/ctkdeb/icon.png" width="100" height="100">
+</p>
+
+The easiest way to create a DEB or RPM package of your CustomTkinter project! You can create a small DEB or RPM package without deep packaging experience.
+
+## Install
+
+```bash
+pip install CTkDeb[gui]
+```
+
+- Creating **DEB** packages requires the `dpkg-deb` tool (pre-installed on most Debian-like systems, probably does not need to be installed separately).
+- Creating **RPM** packages requires the `rpmbuild` tool.
+
+## Run
+
+Run this in the project folder (relative to which the paths in the config are specified)
+
+```
+ctkdeb-gui
+```
+
+## GUI
+
+![Screenshot](https://raw.githubusercontent.com/limafresh/CTkDeb/main/screenshot.png)
+
+## CLI
+
+```
+ctkdeb config.json --create deb
+```
+
+View all arguments:
+
+```
+ctkdeb --help
+```
+
+## Python
+
+```python
+from ctkdeb import Packager
+
+packager = Packager("config.json")
+packager.create_deb()
+# or
+packager.create_rpm("fedora")
+```
+
+View all supported RPM distros:
+
+```python
+from ctkdeb import show_supported_rpm_distros
+show_supported_rpm_distros()
+```
+
+Arguments:
+
+| Argument | Type | Description |
+|-|-|-|
+| **json_path** | *str* or *dict* | Path to the JSON config (or its dict), required |
+| **project_folder** | *str* | Path to the project folder (if the command is not executed from it) |
+| **desktop_entry** | *str* | Path to the custom desktop entry (or its text) |
+| **output_folder** | *str* | Path to the output folder |
+
+## FAQ
+
+- Do I need to specify Tkinter and CustomTkinter as dependencies?
+
+No, CTkDeb has already taken care of that; just specify third-party dependencies, if any.
+
+- What about dependencies?
+
+Pip dependencies are recommended only if they are written in pure Python (e.g., CTkMenuBar). If not, it's better to search for the required dependency in the distribution repositories and specify it as a DEB or RPM dependency. For example, for Pillow, specify `python3-pil` for DEB or `python3-pillow` for RPM (Fedora/Mageia) instead of `pillow` in the Pip dependencies line.
+
+## Other
+
+App icon: Claude Sonnet 5.

ctkdeb-0.7.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ctkdeb/__init__.py,sha256=k_DMT5nbPuzf1y4f5E-CPYGndz1s5_LtQZqM0YOTweM,76
+ctkdeb/gui.py,sha256=tLVi0FN7PuUcp_k-jWtkbbNH88ubhB3n6nCfFbaCJMg,13986
+ctkdeb/icon.png,sha256=FyxyVnubMsvKfmOxU7X3pdeqBL_9G7tD09jD2D0hP_M,25249
+ctkdeb/main.py,sha256=Z67CELvht-W0VVBe-zx0WrGVg4zYMjqX2Nks08sRXb8,1443
+ctkdeb/packager.py,sha256=mpaTqW6Fxy0iLw7d7kDkLm8vEg9gSmuEEfPYUL6XoFI,10844
+ctkdeb-0.7.0.dist-info/licenses/LICENSE,sha256=t7myKADPIxwryGtu0Hw4iu5_vRiDiDomJxd-kug6keE,1066
+ctkdeb-0.7.0.dist-info/METADATA,sha256=AMeVDRYHtmNh9Pna080ax8r9B1zU6Xld1vJQjJPKB84,3311
+ctkdeb-0.7.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ctkdeb-0.7.0.dist-info/entry_points.txt,sha256=uFfm8FDJpu7njVLnUl0Go3WWHw6hadSwQ7gMb_5KLuw,87
+ctkdeb-0.7.0.dist-info/top_level.txt,sha256=k5BoZR2FQt8ws_om-5eMVSdkpVxPXFjv6RpHDKgE8cQ,7
+ctkdeb-0.7.0.dist-info/RECORD,,

ctkdeb-0.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ctkdeb-0.7.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+ctkdeb = ctkdeb.main:cli
+
+[gui_scripts]
+ctkdeb-gui = ctkdeb.main:gui

ctkdeb-0.7.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 limafresh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ctkdeb-0.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ctkdeb