v1.7.0: multi-path serving, custom filenames, serve from Library

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: appaKappaK

README.md

@@ -17,7 +17,8 @@ A Python desktop app that fetches, parses, and deduplicates multiple Pi-hole blo
 - Progress bar and per-source status during combine
 - Save combined lists to a local library organized in folders
 - Load saved lists back into the combiner to merge with new sources
-- **Serve List** — hosts the combined list over HTTP on your LAN so Pi-hole can pull it directly via gravity
+- **Serve List** — hosts combined lists over HTTP on your LAN so Pi-hole can pull them directly via gravity; name each served file (e.g. `general.txt`, `tvs.txt`) so multiple lists can be served simultaneously at different URLs for Pi-hole group management
+- **Serve from Library** — serve any saved list directly from the Library tab without re-combining
 - Dark mode desktop GUI (customtkinter)
 - Window and taskbar icon
 - Install desktop shortcut / launcher entry (Linux)
@@ -45,13 +46,16 @@ The app opens with three tabs:
 ### Pushing to Pi-hole
 
 1. Build your combined list in the Combine tab
-2. Click **Serve List** — the `●` indicator turns green and a URL appears (e.g. `http://YOUR.IP.GO.HERE:8765/blocklist.txt`)
-3. Copy the URL and paste it into Pi-hole's **Adlists** page
-4. Run **Update Gravity** in Pi-hole — it fetches and caches the list
-5. Click **Stop Serving** or close the app — Pi-hole retains the list from its gravity cache
+2. Optionally type a filename (e.g. `general`) — leave blank for the default `blocklist.txt`
+3. Click **Serve List** — the `●` indicator turns green and a URL appears (e.g. `http://YOUR.IP.GO.HERE:8765/general.txt`)
+4. Copy the URL and paste it into Pi-hole's **Adlists** page
+5. Run **Update Gravity** in Pi-hole — it fetches and caches the list
+6. Click **Stop Serving** or close the app — Pi-hole retains the list from its gravity cache
 
 > Pi-hole and your PC just need to be on the same local network. The server defaults to port **8765**.
 
+> **Tip:** To use Pi-hole's group management, build separate lists (e.g. one for general devices, one for smart TVs) and serve each with a different filename. Each URL is a separate adlist entry in Pi-hole that can be assigned to different groups.
+
 ### Output format
 
 When you click *Combine All*, the app produces a plain-text file with a short comment header followed by one domain per line, sorted alphabetically:
@@ -106,6 +110,7 @@ tests/
   test_fetcher.py
   test_combiner.py
   test_database.py
+  test_server.py
 ```
 
 ## Data storage
@@ -135,6 +140,11 @@ pytest tests/
 
 ## Recent updates
 
+**v1.7.0**
+- **Multi-path serving** — the HTTP server now supports serving multiple lists simultaneously at different URL paths; enables Pi-hole group management with separate lists per device group
+- **Custom serve filename** — name the served file in the Combine tab (e.g. `general` → `/general.txt`) instead of the fixed `/blocklist.txt`
+- **Serve from Library** — serve any saved list directly from the Library tab with its own URL, without needing to re-combine
+
 **v1.6.0**
 - **Settings persistence** — port and Blocklist/Allowlist choice now saved to the local database; restored automatically on next launch
 - **Source metadata** — when saving a combined list to the library, the source URLs are stored alongside it; loading the list back into the Combine tab restores the individual URLs (not just the content blob) so you can see where it came from and re-fetch fresh data

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "piholecombinelist"
-version = "1.6.0"
+version = "1.7.0"
 requires-python = ">=3.9"
 dependencies = [
     "requests>=2.28.0",

src/piholecombinelist/__init__.py

@@ -1,7 +1,7 @@
 """Pi-hole Combined Blocklist Generator."""
-# v1.6.0
+# v1.7.0
 
-__version__ = "1.6.0"
+__version__ = "1.7.0"
 
 from .combiner import ListCombiner
 from .database import Database

src/piholecombinelist/gui/app.py

@@ -67,6 +67,7 @@ def __init__(self) -> None:
             self._db,
             get_combine_tab_cb=lambda: self._combine_tab,
             switch_to_combine_cb=lambda: self._tabs.set("Combine"),
+            server=self._server,
         )
         self._library_tab.pack(fill="both", expand=True)
 

src/piholecombinelist/gui/combine_tab.py

@@ -142,6 +142,10 @@ def __init__(self, parent, db: Database, switch_to_library_cb, server: ListServe
         self._server = server
         self._list_type_var = list_type_var
 
+        # Whether the Combine tab is currently serving; tracks the active path
+        self._serving: bool = False
+        self._serving_path: str = ""
+
         # url → credit name, populated by _extract_urls()
         self._url_credits: dict[str, str] = {}
 
@@ -276,6 +280,13 @@ def _build_ui(self) -> None:
             serve_row, text="Serve List", width=110, command=self._toggle_serve
         )
         self._serve_btn.pack(side="left", padx=(0, 8))
+        self._serve_name_entry = ctk.CTkEntry(
+            serve_row, placeholder_text="blocklist", width=120
+        )
+        self._serve_name_entry.pack(side="left", padx=(0, 4))
+        ctk.CTkLabel(serve_row, text=".txt", text_color="gray60").pack(
+            side="left", padx=(0, 8)
+        )
         self._serve_url_var = ctk.StringVar()
         self._serve_url_entry = ctk.CTkEntry(
             serve_row, textvariable=self._serve_url_var, width=280, state="disabled",
@@ -473,24 +484,42 @@ def _save_to_library(self) -> None:
 
     # ── Serve over HTTP ──────────────────────────────────────────────
 
+    def _serve_path_from_name(self) -> str:
+        """Build a URL path from the filename entry, defaulting to ``/blocklist.txt``."""
+        raw = self._serve_name_entry.get().strip()
+        if not raw:
+            return "/blocklist.txt"
+        # Strip .txt if user typed it, we add it ourselves
+        if raw.lower().endswith(".txt"):
+            raw = raw[:-4]
+        slug = re.sub(r'[^a-zA-Z0-9_-]+', '-', raw).strip('-')
+        return f"/{slug or 'blocklist'}.txt"
+
     def _toggle_serve(self) -> None:
-        if self._server.is_running:
-            self._server.stop()
+        if self._serving:
+            self._server.remove_path(self._serving_path)
+            self._serving = False
+            self._serving_path = ""
             self._serve_indicator.configure(text_color="#C0392B")
             self._serve_btn.configure(text="Serve List", fg_color=["#3B8ED0", "#1F6AA5"])
+            self._serve_name_entry.configure(state="normal")
             self._serve_url_entry.pack_forget()
             self._serve_copy_btn.pack_forget()
         else:
             content = self._output_box.get("1.0", "end").strip()
             if not content:
                 messagebox.showwarning("Nothing to serve", "Combine sources first.")
                 return
+            path = self._serve_path_from_name()
             try:
-                url = self._server.start(content)
+                url = self._server.add_path(path, content)
             except OSError as exc:
                 messagebox.showerror("Server error", f"Could not start server:\n{exc}")
                 return
+            self._serving = True
+            self._serving_path = path
             self._serve_url_var.set(url)
+            self._serve_name_entry.configure(state="disabled")
             self._serve_url_entry.pack(side="left", padx=(0, 8))
             self._serve_copy_btn.pack(side="left")
             self._serve_indicator.configure(text_color="#27AE60")

src/piholecombinelist/gui/library_tab.py

@@ -1,25 +1,39 @@
 """Library tab: browse folders and saved lists, load back into combiner."""
 
 import json
+import re as _re
 from pathlib import Path
 from tkinter import filedialog, messagebox, simpledialog
 from typing import Optional
 
 import customtkinter as ctk
 
 from ..database import Database
+from ..server import ListServer
+
+
+def _slugify(name: str) -> str:
+    """Convert a list name to a URL-safe path component."""
+    slug = name.lower()
+    slug = _re.sub(r'[^a-z0-9]+', '-', slug)
+    slug = slug.strip('-')
+    return slug or "list"
 
 
 class LibraryTab(ctk.CTkFrame):
     """The Library tab: browse folders and saved lists, load back into combiner."""
 
-    def __init__(self, parent, db: Database, get_combine_tab_cb, switch_to_combine_cb) -> None:
+    def __init__(self, parent, db: Database, get_combine_tab_cb, switch_to_combine_cb,
+                 server: ListServer) -> None:
         super().__init__(parent, fg_color="transparent")
         self._db = db
         self._get_combine_tab = get_combine_tab_cb
         self._switch_to_combine = switch_to_combine_cb
+        self._server = server
         self._selected_folder_id: Optional[int] = None  # None = root
         self._selected_list_id: Optional[int] = None
+        # list_id → URL path currently being served (e.g. "/my-general-list.txt")
+        self._served_paths: dict[int, str] = {}
 
         self._build_ui()
         self.refresh()
@@ -104,7 +118,7 @@ def _build_ui(self) -> None:
 
         # Move-to row
         move_row = ctk.CTkFrame(right, fg_color="transparent")
-        move_row.grid(row=4, column=0, sticky="ew", padx=10, pady=(0, 10))
+        move_row.grid(row=4, column=0, sticky="ew", padx=10, pady=(0, 4))
         ctk.CTkLabel(move_row, text="Move to folder:").pack(side="left", padx=(0, 8))
         self._move_folder_var = ctk.StringVar(value="🏠 Root")
         self._move_menu = ctk.CTkOptionMenu(
@@ -115,6 +129,26 @@ def _build_ui(self) -> None:
             side="left"
         )
 
+        # Serve row — host a saved list over HTTP for Pi-hole
+        serve_row = ctk.CTkFrame(right, fg_color="transparent")
+        serve_row.grid(row=5, column=0, sticky="ew", padx=10, pady=(0, 10))
+        self._lib_serve_indicator = ctk.CTkLabel(
+            serve_row, text="●", text_color="#C0392B", width=16
+        )
+        self._lib_serve_indicator.pack(side="left", padx=(0, 4))
+        self._lib_serve_btn = ctk.CTkButton(
+            serve_row, text="Serve", width=90, command=self._toggle_lib_serve
+        )
+        self._lib_serve_btn.pack(side="left", padx=(0, 8))
+        self._lib_serve_url_var = ctk.StringVar()
+        self._lib_serve_url_entry = ctk.CTkEntry(
+            serve_row, textvariable=self._lib_serve_url_var, width=280, state="disabled",
+        )
+        self._lib_serve_copy_btn = ctk.CTkButton(
+            serve_row, text="Copy URL", width=80, command=self._copy_lib_serve_url
+        )
+        # URL entry + copy button hidden until a list is being served
+
     # ── Refresh helpers ──────────────────────────────────────────────
 
     def refresh(self) -> None:
@@ -232,12 +266,27 @@ def _select_list(self, list_id: int) -> None:
         self._lib_dupes_label.configure(
             text=f"Duplicates removed: {row['duplicates_removed']}"
         )
+        # Reflect serve state for this list
+        if list_id in self._served_paths:
+            self._lib_serve_indicator.configure(text_color="#27AE60")
+            self._lib_serve_btn.configure(text="Stop Serving", fg_color=["#C0392B", "#922B21"])
+            self._lib_serve_url_var.set(self._server.url_for(self._served_paths[list_id]))
+            self._lib_serve_url_entry.pack(side="left", padx=(0, 8))
+            self._lib_serve_copy_btn.pack(side="left")
+        else:
+            self._lib_serve_indicator.configure(text_color="#C0392B")
+            self._lib_serve_btn.configure(text="Serve", fg_color=["#3B8ED0", "#1F6AA5"])
+            self._lib_serve_url_entry.pack_forget()
+            self._lib_serve_copy_btn.pack_forget()
 
     def _delete_list(self) -> None:
         if self._selected_list_id is None:
             messagebox.showinfo("Select a list", "Select a list to delete.")
             return
         if messagebox.askyesno("Delete list", "Delete this list?", parent=self):
+            # Stop serving this list if it's active
+            if self._selected_list_id in self._served_paths:
+                self._server.remove_path(self._served_paths.pop(self._selected_list_id))
             self._db.delete_list(self._selected_list_id)
             self._selected_list_id = None
             self._content_box.configure(state="normal")
@@ -285,6 +334,52 @@ def _load_into_combiner(self) -> None:
             combine_tab.load_content_as_source(f"[library] {row['name']}", row["content"])
         self._switch_to_combine()
 
+    # ── Serve from Library ─────────────────────────────────────────
+
+    def _make_path(self, list_id: int, name: str) -> str:
+        """Return a unique ``/slug.txt`` path for *list_id*, avoiding collisions."""
+        base = _slugify(name)
+        candidate = f"/{base}.txt"
+        for lid, p in self._served_paths.items():
+            if p == candidate and lid != list_id:
+                candidate = f"/{base}-{list_id}.txt"
+                break
+        return candidate
+
+    def _toggle_lib_serve(self) -> None:
+        if self._selected_list_id is None:
+            messagebox.showinfo("Select a list", "Select a list to serve.")
+            return
+        lid = self._selected_list_id
+        if lid in self._served_paths:
+            # Stop serving this list
+            self._server.remove_path(self._served_paths.pop(lid))
+            self._lib_serve_indicator.configure(text_color="#C0392B")
+            self._lib_serve_btn.configure(text="Serve", fg_color=["#3B8ED0", "#1F6AA5"])
+            self._lib_serve_url_entry.pack_forget()
+            self._lib_serve_copy_btn.pack_forget()
+        else:
+            row = self._db.get_list(lid)
+            if not row:
+                return
+            path = self._make_path(lid, row["name"])
+            try:
+                url = self._server.add_path(path, row["content"])
+            except OSError as exc:
+                messagebox.showerror("Server error", f"Could not start server:\n{exc}")
+                return
+            self._served_paths[lid] = path
+            self._lib_serve_url_var.set(url)
+            self._lib_serve_url_entry.pack(side="left", padx=(0, 8))
+            self._lib_serve_copy_btn.pack(side="left")
+            self._lib_serve_indicator.configure(text_color="#27AE60")
+            self._lib_serve_btn.configure(text="Stop Serving", fg_color=["#C0392B", "#922B21"])
+
+    def _copy_lib_serve_url(self) -> None:
+        self.clipboard_clear()
+        self.clipboard_append(self._lib_serve_url_var.get())
+        messagebox.showinfo("Copied", "URL copied — paste it into Pi-hole's Adlists page,\nthen run gravity.")
+
     def _move_list(self) -> None:
         if self._selected_list_id is None:
             messagebox.showinfo("Select a list", "Select a list to move.")

src/piholecombinelist/server.py

@@ -1,5 +1,5 @@
-"""Minimal HTTP server that serves the combined blocklist as plain text."""
-# v1.0.0
+"""Minimal HTTP server that serves combined blocklists as plain text."""
+# v1.7.0
 
 import http.server
 import socket
@@ -25,29 +25,63 @@ class _ReuseAddrServer(socketserver.TCPServer):
 
 
 class ListServer:
-    """Serves a blocklist as plain text over HTTP on /blocklist.txt."""
+    """Serves one or more blocklists as plain text over HTTP on distinct paths."""
 
     DEFAULT_PORT = 8765
 
     def __init__(self, port: int = DEFAULT_PORT) -> None:
         self._port = port
         self._server: Optional[_ReuseAddrServer] = None
         self._thread: Optional[threading.Thread] = None
+        self._paths: dict[str, bytes] = {}
 
     @property
     def is_running(self) -> bool:
         return self._server is not None
 
+    # ── Public API ────────────────────────────────────────────────
+
+    def add_path(self, path: str, content: str) -> str:
+        """Register *path* with *content*. Starts the server if needed.
+
+        Returns the full URL for that path.
+        """
+        self._paths[path] = content.encode("utf-8")
+        if not self._server:
+            self._start_server()
+        return f"http://{_local_ip()}:{self._port}{path}"
+
+    def remove_path(self, path: str) -> None:
+        """Remove *path*. Stops the server when no paths remain."""
+        self._paths.pop(path, None)
+        if not self._paths:
+            self._stop_server()
+
     def start(self, content: str) -> str:
-        """Start serving *content*. Returns the URL to add to Pi-hole's Adlists."""
-        if self._server:
-            self.stop()
+        """Compatibility wrapper: serve *content* at ``/blocklist.txt``."""
+        return self.add_path("/blocklist.txt", content)
 
-        payload = content.encode("utf-8")
+    def stop(self) -> None:
+        """Full shutdown: clear all paths and stop the server."""
+        self._paths.clear()
+        self._stop_server()
+
+    def has_path(self, path: str) -> bool:
+        return path in self._paths
+
+    def url_for(self, path: str) -> str:
+        """Return the full URL for an already-registered *path*."""
+        return f"http://{_local_ip()}:{self._port}{path}"
+
+    # ── Internal ──────────────────────────────────────────────────
+
+    def _start_server(self) -> None:
+        paths = self._paths  # reference — handler always sees latest entries
 
         class _Handler(http.server.BaseHTTPRequestHandler):
             def do_GET(self):  # noqa: N802
-                if self.path in ("/", "/blocklist.txt"):
+                payload = paths.get(self.path)
+                if payload is not None:
                     self.send_response(200)
                     self.send_header("Content-Type", "text/plain; charset=utf-8")
                     self.send_header("Content-Length", str(len(payload)))
@@ -65,9 +99,8 @@ def log_message(self, *_):
             target=self._server.serve_forever, daemon=True, name="phlist-server"
         )
         self._thread.start()
-        return f"http://{_local_ip()}:{self._port}/blocklist.txt"
 
-    def stop(self) -> None:
+    def _stop_server(self) -> None:
         if self._server:
             self._server.shutdown()
             self._server.server_close()