PyCodeTools 0.1.0__tar.gz

pycodetools-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: PyCodeTools
+Version: 0.1.0
+Summary: Run Python scripts with extra scripting helpers, and package them into .exe files from a simple GUI.
+Author: Your Name
+License: MIT
+Project-URL: Homepage, https://pct.ct.ws
+Keywords: cli,scripting,pyinstaller,tkinter,build tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.0; extra == "build"
+
+# PyCodeTools (PCT)
+
+Run Python scripts with a few extra scripting helpers, and package them
+into standalone `.exe` files from a simple Tkinter GUI — all from the
+command line.
+
+## Install
+
+```bash
+pip install PyCodeTools
+```
+
+This gives you two equivalent commands: `pycodetools` and `pct`.
+
+## Enabling PCT in a script
+
+Add this as the **first line** of your `.py` file:
+
+```python
+pycodetools = {true}PCT.enable
+print("pycodetools")
+```
+
+That first line is what PCT looks for. It's still valid, harmless Python
+(just a variable assignment) if someone runs the file normally with
+`python file.py` — but when you run it through PCT, PCT detects it,
+prints a confirmation, and unlocks extra helpers for your script.
+
+## Running a script
+
+```bash
+pct myscript.py
+# or explicitly:
+pct run myscript.py
+# or the long form:
+pycodetools myscript.py
+```
+
+If the enable line is found, you'll see:
+
+```
+{true}PCT.enable
+PyCodeTools is now enabled for this run.
+Running: py myscript.py
+----------------------------------------
+pycodetools
+```
+
+## Extra helpers in your script
+
+Once enabled, your script can use the extra helper functions by
+importing the package:
+
+```python
+pycodetools = {true}PCT.enable
+import pycodetools as pct
+
+if pct.enabled:
+    pct.title("My App")
+    pct.banner("Welcome!")
+    print(pct.color("This is red text", "red"))
+    pct.timer(3)
+    if pct.confirm("Keep going?"):
+        print("Continuing...")
+    pct.pause()
+```
+
+Available helpers:
+
+| Function | What it does |
+|---|---|
+| `pct.title(text)` | Sets the terminal window title |
+| `pct.clear()` | Clears the terminal |
+| `pct.pause(msg=...)` | "Press Enter to continue..." prompt |
+| `pct.banner(text)` | Prints a boxed banner |
+| `pct.color(text, name)` | Returns ANSI-colored text |
+| `pct.timer(seconds)` | Countdown timer |
+| `pct.confirm(prompt)` | Yes/No prompt, returns bool |
+| `pct.enabled` | `True` if the enable line was detected |
+
+## Config / Build GUI
+
+```bash
+pct config myscript.py
+```
+
+Opens a Tkinter window with two tabs:
+
+- **Dependencies** — pick from a preset list of common packages (or type
+  a custom one) and install them with pip.
+- **Build .exe** — compile the script into a standalone executable using
+  [PyInstaller](https://pyinstaller.org/), with options for one-file
+  builds, hiding the console window, and naming the output.
+
+Building `.exe` files requires PyInstaller:
+
+```bash
+pip install PyCodeTools[build]
+```
+
+## License
+
+MIT

pycodetools-0.1.0/README.md

@@ -0,0 +1,103 @@
+# PyCodeTools (PCT)
+
+Run Python scripts with a few extra scripting helpers, and package them
+into standalone `.exe` files from a simple Tkinter GUI — all from the
+command line.
+
+## Install
+
+```bash
+pip install PyCodeTools
+```
+
+This gives you two equivalent commands: `pycodetools` and `pct`.
+
+## Enabling PCT in a script
+
+Add this as the **first line** of your `.py` file:
+
+```python
+pycodetools = {true}PCT.enable
+print("pycodetools")
+```
+
+That first line is what PCT looks for. It's still valid, harmless Python
+(just a variable assignment) if someone runs the file normally with
+`python file.py` — but when you run it through PCT, PCT detects it,
+prints a confirmation, and unlocks extra helpers for your script.
+
+## Running a script
+
+```bash
+pct myscript.py
+# or explicitly:
+pct run myscript.py
+# or the long form:
+pycodetools myscript.py
+```
+
+If the enable line is found, you'll see:
+
+```
+{true}PCT.enable
+PyCodeTools is now enabled for this run.
+Running: py myscript.py
+----------------------------------------
+pycodetools
+```
+
+## Extra helpers in your script
+
+Once enabled, your script can use the extra helper functions by
+importing the package:
+
+```python
+pycodetools = {true}PCT.enable
+import pycodetools as pct
+
+if pct.enabled:
+    pct.title("My App")
+    pct.banner("Welcome!")
+    print(pct.color("This is red text", "red"))
+    pct.timer(3)
+    if pct.confirm("Keep going?"):
+        print("Continuing...")
+    pct.pause()
+```
+
+Available helpers:
+
+| Function | What it does |
+|---|---|
+| `pct.title(text)` | Sets the terminal window title |
+| `pct.clear()` | Clears the terminal |
+| `pct.pause(msg=...)` | "Press Enter to continue..." prompt |
+| `pct.banner(text)` | Prints a boxed banner |
+| `pct.color(text, name)` | Returns ANSI-colored text |
+| `pct.timer(seconds)` | Countdown timer |
+| `pct.confirm(prompt)` | Yes/No prompt, returns bool |
+| `pct.enabled` | `True` if the enable line was detected |
+
+## Config / Build GUI
+
+```bash
+pct config myscript.py
+```
+
+Opens a Tkinter window with two tabs:
+
+- **Dependencies** — pick from a preset list of common packages (or type
+  a custom one) and install them with pip.
+- **Build .exe** — compile the script into a standalone executable using
+  [PyInstaller](https://pyinstaller.org/), with options for one-file
+  builds, hiding the console window, and naming the output.
+
+Building `.exe` files requires PyInstaller:
+
+```bash
+pip install PyCodeTools[build]
+```
+
+## License
+
+MIT

pycodetools-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PyCodeTools"
+version = "0.1.0"
+description = "Run Python scripts with extra scripting helpers, and package them into .exe files from a simple GUI."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Your Name" }
+]
+keywords = ["cli", "scripting", "pyinstaller", "tkinter", "build tools"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Software Development :: Build Tools",
+]
+dependencies = []
+
+[project.optional-dependencies]
+build = ["pyinstaller>=6.0"]
+
+[project.scripts]
+pycodetools = "pycodetools.cli:main"
+pct = "pycodetools.cli:main"
+
+[project.urls]
+Homepage = "https://pct.ct.ws"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pycodetools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pycodetools-0.1.0/src/PyCodeTools.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: PyCodeTools
+Version: 0.1.0
+Summary: Run Python scripts with extra scripting helpers, and package them into .exe files from a simple GUI.
+Author: Your Name
+License: MIT
+Project-URL: Homepage, https://pct.ct.ws
+Keywords: cli,scripting,pyinstaller,tkinter,build tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.0; extra == "build"
+
+# PyCodeTools (PCT)
+
+Run Python scripts with a few extra scripting helpers, and package them
+into standalone `.exe` files from a simple Tkinter GUI — all from the
+command line.
+
+## Install
+
+```bash
+pip install PyCodeTools
+```
+
+This gives you two equivalent commands: `pycodetools` and `pct`.
+
+## Enabling PCT in a script
+
+Add this as the **first line** of your `.py` file:
+
+```python
+pycodetools = {true}PCT.enable
+print("pycodetools")
+```
+
+That first line is what PCT looks for. It's still valid, harmless Python
+(just a variable assignment) if someone runs the file normally with
+`python file.py` — but when you run it through PCT, PCT detects it,
+prints a confirmation, and unlocks extra helpers for your script.
+
+## Running a script
+
+```bash
+pct myscript.py
+# or explicitly:
+pct run myscript.py
+# or the long form:
+pycodetools myscript.py
+```
+
+If the enable line is found, you'll see:
+
+```
+{true}PCT.enable
+PyCodeTools is now enabled for this run.
+Running: py myscript.py
+----------------------------------------
+pycodetools
+```
+
+## Extra helpers in your script
+
+Once enabled, your script can use the extra helper functions by
+importing the package:
+
+```python
+pycodetools = {true}PCT.enable
+import pycodetools as pct
+
+if pct.enabled:
+    pct.title("My App")
+    pct.banner("Welcome!")
+    print(pct.color("This is red text", "red"))
+    pct.timer(3)
+    if pct.confirm("Keep going?"):
+        print("Continuing...")
+    pct.pause()
+```
+
+Available helpers:
+
+| Function | What it does |
+|---|---|
+| `pct.title(text)` | Sets the terminal window title |
+| `pct.clear()` | Clears the terminal |
+| `pct.pause(msg=...)` | "Press Enter to continue..." prompt |
+| `pct.banner(text)` | Prints a boxed banner |
+| `pct.color(text, name)` | Returns ANSI-colored text |
+| `pct.timer(seconds)` | Countdown timer |
+| `pct.confirm(prompt)` | Yes/No prompt, returns bool |
+| `pct.enabled` | `True` if the enable line was detected |
+
+## Config / Build GUI
+
+```bash
+pct config myscript.py
+```
+
+Opens a Tkinter window with two tabs:
+
+- **Dependencies** — pick from a preset list of common packages (or type
+  a custom one) and install them with pip.
+- **Build .exe** — compile the script into a standalone executable using
+  [PyInstaller](https://pyinstaller.org/), with options for one-file
+  builds, hiding the console window, and naming the output.
+
+Building `.exe` files requires PyInstaller:
+
+```bash
+pip install PyCodeTools[build]
+```
+
+## License
+
+MIT

pycodetools-0.1.0/src/PyCodeTools.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/PyCodeTools.egg-info/PKG-INFO
+src/PyCodeTools.egg-info/SOURCES.txt
+src/PyCodeTools.egg-info/dependency_links.txt
+src/PyCodeTools.egg-info/entry_points.txt
+src/PyCodeTools.egg-info/requires.txt
+src/PyCodeTools.egg-info/top_level.txt
+src/pycodetools/__init__.py
+src/pycodetools/cli.py
+src/pycodetools/gui.py

pycodetools-0.1.0/src/PyCodeTools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pycodetools-0.1.0/src/PyCodeTools.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pct = pycodetools.cli:main
+pycodetools = pycodetools.cli:main

pycodetools-0.1.0/src/PyCodeTools.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[build]
+pyinstaller>=6.0

pycodetools-0.1.0/src/PyCodeTools.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycodetools

pycodetools-0.1.0/src/pycodetools/__init__.py

@@ -0,0 +1,104 @@
+"""
+PyCodeTools (PCT)
+=================
+
+A tiny helper toolkit + CLI for running Python scripts with a few
+extra scripting conveniences, and a GUI for turning them into .exe
+files with PyInstaller.
+
+Enabling PCT in a script
+-------------------------
+Put this as the first line of your script::
+
+    pycodetools = {true}PCT.enable
+
+When you run the file with the ``pycodetools`` (or ``pct``) command,
+PCT will detect that line and print a confirmation, then run your
+script with the extra helpers available via::
+
+    import pycodetools as pct
+
+Extra helpers available once enabled
+-------------------------------------
+- pct.title("My App")      -> sets the terminal window title
+- pct.clear()               -> clears the terminal screen
+- pct.pause(msg="...")      -> "Press Enter to continue..." style pause
+- pct.banner("text")        -> prints a nice banner
+- pct.color("text", "red")  -> returns text wrapped in ANSI color codes
+- pct.timer(seconds)        -> countdown in the terminal
+- pct.confirm("Continue?")  -> yes/no prompt returning bool
+- pct.enabled                -> True if PCT enable line was detected
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+
+__version__ = "0.1.0"
+
+# Set to True by the pycodetools launcher when it detects the enable line.
+# Scripts run directly with `python file.py` will have this as False,
+# since the enable line by itself is just a harmless variable assignment.
+enabled: bool = False
+
+_COLORS = {
+    "red": "31",
+    "green": "32",
+    "yellow": "33",
+    "blue": "34",
+    "magenta": "35",
+    "cyan": "36",
+    "white": "37",
+}
+
+
+def title(text: str) -> None:
+    """Set the terminal window title (Windows + most ANSI terminals)."""
+    if os.name == "nt":
+        os.system(f"title {text}")
+    else:
+        sys.stdout.write(f"\33]0;{text}\a")
+        sys.stdout.flush()
+
+
+def clear() -> None:
+    """Clear the terminal screen."""
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+def pause(msg: str = "Press Enter to continue...") -> None:
+    """Pause execution until the user presses Enter."""
+    input(msg)
+
+
+def banner(text: str, char: str = "=") -> None:
+    """Print a simple banner around text."""
+    line = char * (len(text) + 4)
+    print(line)
+    print(f"{char} {text} {char}")
+    print(line)
+
+
+def color(text: str, name: str = "white") -> str:
+    """Wrap text in an ANSI color code (returns a string, doesn't print)."""
+    code = _COLORS.get(name.lower(), "37")
+    return f"\033[{code}m{text}\033[0m"
+
+
+def timer(seconds: int, label: str = "Starting in") -> None:
+    """Countdown timer printed to the terminal."""
+    for i in range(seconds, 0, -1):
+        print(f"\r{label} {i}...", end="", flush=True)
+        time.sleep(1)
+    print(f"\r{label} 0...   ")
+
+
+def confirm(prompt: str = "Continue?") -> bool:
+    """Ask a yes/no question, returns True/False."""
+    ans = input(f"{prompt} [y/N]: ").strip().lower()
+    return ans in ("y", "yes")
+
+
+ENABLE_LINE = "pycodetools = {true}PCT.enable"

pycodetools-0.1.0/src/pycodetools/cli.py

@@ -0,0 +1,145 @@
+"""
+Command line interface for PyCodeTools.
+
+Usage:
+    pycodetools <file.py>          Run a script (checks for the enable line)
+    pycodetools run <file.py>      Same as above, explicit form
+    pycodetools config <file.py>   Open the Tkinter build/config GUI
+    pct <file.py>                  Alias for pycodetools
+    pct config <file.py>           Alias for pycodetools config
+
+The enable line
+----------------
+If the first non-blank line of the target file is exactly:
+
+    pycodetools = {true}PCT.enable
+
+PCT will print a confirmation and run the script with the
+`pycodetools` helper module's `enabled` flag set to True, so the
+script can do:
+
+    import pycodetools as pct
+    if pct.enabled:
+        pct.banner("PCT features on")
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import ENABLE_LINE
+from . import __version__
+
+
+def _read_first_meaningful_line(path: Path) -> str:
+    with path.open("r", encoding="utf-8", errors="replace") as f:
+        for line in f:
+            stripped = line.strip()
+            if stripped:
+                return stripped
+    return ""
+
+
+def _run_file(file_path: str) -> int:
+    path = Path(file_path)
+    if not path.exists():
+        print(f"pct: error: no such file: {file_path}", file=sys.stderr)
+        return 1
+    if path.suffix != ".py":
+        print(f"pct: warning: '{file_path}' doesn't end in .py, running anyway")
+
+    first_line = _read_first_meaningful_line(path)
+    is_enabled = first_line == ENABLE_LINE
+
+    # Set the enabled flag on our own module before the target script
+    # imports it, so `import pycodetools as pct; pct.enabled` works.
+    import pycodetools as pct_module
+    pct_module.enabled = is_enabled
+
+    if is_enabled:
+        print("{true}PCT.enable")
+        print("PyCodeTools is now enabled for this run.")
+    else:
+        print("PyCodeTools: enable line not found, running as a plain script.")
+
+    print(f"Running: py {path.name}\n" + ("-" * 40))
+
+    source = path.read_text(encoding="utf-8", errors="replace")
+    if is_enabled:
+        # The enable line uses PCT's special "{true}PCT.enable" marker
+        # syntax, which is not valid Python. Replace just that first
+        # line with a real, equivalent assignment so the rest of the
+        # file still runs normally.
+        lines = source.splitlines(keepends=True)
+        for idx, line in enumerate(lines):
+            if line.strip() == ENABLE_LINE:
+                lines[idx] = "pycodetools = True\n"
+                break
+        source = "".join(lines)
+
+    code = compile(source, str(path), "exec")
+
+    old_argv = sys.argv
+    sys.argv = [str(path)]
+    try:
+        exec(code, {"__name__": "__main__", "__file__": str(path)})
+    except SystemExit as e:
+        return int(e.code) if isinstance(e.code, int) else 0
+    finally:
+        sys.argv = old_argv
+    return 0
+
+
+def _open_config(file_path: str) -> int:
+    path = Path(file_path)
+    if not path.exists():
+        print(f"pct: error: no such file: {file_path}", file=sys.stderr)
+        return 1
+
+    from .gui import launch_config_gui
+    launch_config_gui(path)
+    return 0
+
+
+def main(argv=None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        prog="pct",
+        description="PyCodeTools (PCT) - run and package Python scripts.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"PyCodeTools {__version__}"
+    )
+    if argv and argv[0] == "--version":
+        print(f"PyCodeTools {__version__}")
+        return 0
+
+    if not argv:
+        parser.print_help()
+        return 0
+
+    if argv[0] == "run":
+        if len(argv) < 2:
+            print("pct: error: 'run' requires a file argument", file=sys.stderr)
+            return 2
+        return _run_file(argv[1])
+
+    if argv[0] == "config":
+        if len(argv) < 2:
+            print("pct: error: 'config' requires a file argument", file=sys.stderr)
+            return 2
+        return _open_config(argv[1])
+
+    if argv[0] in ("-h", "--help"):
+        parser.print_help()
+        return 0
+
+    # Bare `pct file.py`
+    return _run_file(argv[0])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pycodetools-0.1.0/src/pycodetools/gui.py

@@ -0,0 +1,213 @@
+"""
+Tkinter GUI launched by `pct config <file.py>`.
+
+Lets you:
+  - Pick dependencies from a preset list (or add custom ones) and
+    pip-install them.
+  - Compile the target script into a standalone .exe using PyInstaller.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+import tkinter as tk
+from tkinter import ttk, messagebox, scrolledtext
+
+# A starter list of common packages people often need. Not exhaustive -
+# custom packages can be typed in too.
+COMMON_DEPENDENCIES = [
+    "requests",
+    "numpy",
+    "pandas",
+    "matplotlib",
+    "pillow",
+    "flask",
+    "django",
+    "beautifulsoup4",
+    "pygame",
+    "opencv-python",
+    "scikit-learn",
+    "tqdm",
+    "pyinstaller",
+    "python-dotenv",
+    "colorama",
+    "rich",
+    "sqlalchemy",
+    "pytest",
+    "pyyaml",
+    "click",
+]
+
+
+class PCTConfigApp:
+    def __init__(self, root: tk.Tk, target_file: Path):
+        self.root = root
+        self.target_file = target_file
+        self.root.title(f"PyCodeTools Config - {target_file.name}")
+        self.root.geometry("560x600")
+        self.root.minsize(480, 500)
+
+        self._build_ui()
+
+    # ---------- UI construction ----------
+
+    def _build_ui(self) -> None:
+        pad = {"padx": 10, "pady": 6}
+
+        header = ttk.Label(
+            self.root,
+            text=f"Configuring: {self.target_file}",
+            font=("Segoe UI", 10, "bold"),
+            wraplength=520,
+        )
+        header.pack(fill="x", **pad)
+
+        notebook = ttk.Notebook(self.root)
+        notebook.pack(fill="both", expand=True, padx=10, pady=6)
+
+        deps_tab = ttk.Frame(notebook)
+        build_tab = ttk.Frame(notebook)
+        notebook.add(deps_tab, text="Dependencies")
+        notebook.add(build_tab, text="Build .exe")
+
+        self._build_deps_tab(deps_tab)
+        self._build_build_tab(build_tab)
+
+        # Shared log/output box at the bottom
+        log_label = ttk.Label(self.root, text="Output:")
+        log_label.pack(anchor="w", padx=10)
+        self.log_box = scrolledtext.ScrolledText(self.root, height=10, state="disabled")
+        self.log_box.pack(fill="both", expand=False, padx=10, pady=(0, 10))
+
+    def _build_deps_tab(self, parent: ttk.Frame) -> None:
+        ttk.Label(parent, text="Pick dependencies to install:").pack(
+            anchor="w", padx=10, pady=(10, 2)
+        )
+
+        list_frame = ttk.Frame(parent)
+        list_frame.pack(fill="both", expand=True, padx=10, pady=4)
+
+        self.deps_listbox = tk.Listbox(
+            list_frame, selectmode="multiple", height=10, exportselection=False
+        )
+        for dep in COMMON_DEPENDENCIES:
+            self.deps_listbox.insert("end", dep)
+        scrollbar = ttk.Scrollbar(
+            list_frame, orient="vertical", command=self.deps_listbox.yview
+        )
+        self.deps_listbox.configure(yscrollcommand=scrollbar.set)
+        self.deps_listbox.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+
+        custom_frame = ttk.Frame(parent)
+        custom_frame.pack(fill="x", padx=10, pady=6)
+        ttk.Label(custom_frame, text="Custom package:").pack(side="left")
+        self.custom_dep_entry = ttk.Entry(custom_frame)
+        self.custom_dep_entry.pack(side="left", fill="x", expand=True, padx=6)
+
+        install_btn = ttk.Button(
+            parent, text="Install Selected", command=self._install_dependencies
+        )
+        install_btn.pack(pady=6)
+
+    def _build_build_tab(self, parent: ttk.Frame) -> None:
+        ttk.Label(
+            parent,
+            text="Compile this script into a standalone .exe using PyInstaller.",
+            wraplength=500,
+        ).pack(anchor="w", padx=10, pady=(10, 6))
+
+        opts_frame = ttk.LabelFrame(parent, text="Options")
+        opts_frame.pack(fill="x", padx=10, pady=6)
+
+        self.onefile_var = tk.BooleanVar(value=True)
+        ttk.Checkbutton(
+            opts_frame, text="Single file (--onefile)", variable=self.onefile_var
+        ).pack(anchor="w", padx=8, pady=2)
+
+        self.console_var = tk.BooleanVar(value=True)
+        ttk.Checkbutton(
+            opts_frame,
+            text="Show console window (uncheck for --noconsole/GUI apps)",
+            variable=self.console_var,
+        ).pack(anchor="w", padx=8, pady=2)
+
+        name_frame = ttk.Frame(opts_frame)
+        name_frame.pack(fill="x", padx=8, pady=4)
+        ttk.Label(name_frame, text="Output name:").pack(side="left")
+        self.exe_name_entry = ttk.Entry(name_frame)
+        self.exe_name_entry.insert(0, self.target_file.stem)
+        self.exe_name_entry.pack(side="left", fill="x", expand=True, padx=6)
+
+        build_btn = ttk.Button(
+            parent, text="Build .exe", command=self._build_exe
+        )
+        build_btn.pack(pady=10)
+
+    # ---------- Logging helper ----------
+
+    def _log(self, text: str) -> None:
+        self.log_box.configure(state="normal")
+        self.log_box.insert("end", text + "\n")
+        self.log_box.see("end")
+        self.log_box.configure(state="disabled")
+
+    def _run_in_thread(self, cmd: list[str]) -> None:
+        def worker():
+            self._log(f"$ {' '.join(cmd)}")
+            try:
+                proc = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                )
+                for line in proc.stdout:  # type: ignore[union-attr]
+                    self._log(line.rstrip())
+                proc.wait()
+                if proc.returncode == 0:
+                    self._log("Done.")
+                else:
+                    self._log(f"Exited with code {proc.returncode}")
+            except FileNotFoundError as e:
+                self._log(f"Error: {e}")
+            except Exception as e:  # noqa: BLE001
+                self._log(f"Error: {e}")
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    # ---------- Actions ----------
+
+    def _install_dependencies(self) -> None:
+        selected_indices = self.deps_listbox.curselection()
+        packages = [self.deps_listbox.get(i) for i in selected_indices]
+        custom = self.custom_dep_entry.get().strip()
+        if custom:
+            packages.append(custom)
+
+        if not packages:
+            messagebox.showinfo("PyCodeTools", "No packages selected.")
+            return
+
+        cmd = [sys.executable, "-m", "pip", "install", *packages]
+        self._run_in_thread(cmd)
+
+    def _build_exe(self) -> None:
+        name = self.exe_name_entry.get().strip() or self.target_file.stem
+        cmd = [sys.executable, "-m", "PyInstaller"]
+        if self.onefile_var.get():
+            cmd.append("--onefile")
+        if not self.console_var.get():
+            cmd.append("--noconsole")
+        cmd.extend(["--name", name, str(self.target_file)])
+        self._run_in_thread(cmd)
+
+
+def launch_config_gui(target_file: Path) -> None:
+    root = tk.Tk()
+    PCTConfigApp(root, target_file)
+    root.mainloop()