routedel 1.0.3__py3-none-any.whl

routedel/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+# File: src/routedel/__init__.py
+# Author: Hadi Cahyadi <cumulus13@gmail.com>
+# Date: 2026-10-26
+# Description: routedel - delete / add / list / monitor IPv4 routes with ntfy + Growl notifications.
+# License: MIT
+
+"""routedel - delete / add / list / monitor IPv4 routes with ntfy + Growl notifications."""
+__version__ = "1.0.0"

routedel/__main__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+# File: src/routedel/__main__.py
+# Author: Hadi Cahyadi <cumulus13@gmail.com>
+# Date: 2026-10-26
+# Description: 
+# License: MIT
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

routedel/cli.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+
+# File: src/routedel/cli.py
+# Author: Hadi Cahyadi <cumulus13@gmail.com>
+# Date: 2026-10-26
+# Description: Command line interface.
+# License: MIT
+
+"""Command line interface."""
+import argparse
+import ipaddress
+import os
+import sys
+
+from rchf import CustomRichHelpFormatter
+from richcolorlog import setup_logging
+
+from . import __version__
+from .display import console, create_route_table, monitor_routes
+from .notify import APP_NAME, build_notifier
+from .routes import (
+    delete_default,
+    delete_entry,
+    find_by_metric,
+    get_routes,
+    parse_route_table,
+    route_action,
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(formatter_class=CustomRichHelpFormatter, prog=APP_NAME)
+    p.add_argument('data', nargs="*", help='Route string, or "c" to read from clipboard')
+    p.add_argument('-V', '--version', action='version', version=f"{APP_NAME} {__version__}")
+    p.add_argument('-m', '--metric', help='Remove route(s) by metric')
+    p.add_argument('-l', '--list', action='store_true', help='List current routes')
+    p.add_argument('-a', '--add', action='store_true', help='Add route (needs -g and -i; DATA[0]=CIDR unless -d)')
+    p.add_argument('-d', '--default', action='store_true', help='Add as default route')
+    p.add_argument('-g', '--gateway', help='Gateway IP for adding route')
+    p.add_argument('-i', '--interface', help='Interface name for adding route')
+    p.add_argument('--met', type=int, default=0, help='Metric for adding route')
+    p.add_argument('--monitor', action='store_true', help='Monitor routing table in real-time')
+    p.add_argument('--refresh', type=float, default=2.0, help='Monitor refresh seconds (default: 2.0)')
+    p.add_argument('--ntfy', action='append', metavar='URL', help='ntfy topic URL, e.g. https://ntfy.sh/topic (repeatable)')
+    p.add_argument('--growl', action='append', metavar='HOST[:PORT]', help='Growl/GNTP server (repeatable)')
+    p.add_argument('--config', help='Notification config JSON file')
+    p.add_argument('--no-notify', action='store_true', help='Disable all notifications')
+    p.add_argument('--test-notify', action='store_true', help='Send a test notification and exit')
+    return p
+
+
+def main(argv=None):
+    log = setup_logging(exceptions=['pika', 'urllib3', 'urllib2', 'urllib', 'clipboard'])
+    p = build_parser()
+    argv = sys.argv[1:] if argv is None else argv
+    if not argv:
+        p.print_help()
+        sys.exit(0)
+    args = p.parse_args(argv)
+    notifier = build_notifier(args.no_notify, args.config, args.ntfy, args.growl)
+
+    if args.test_notify:
+        if not notifier:
+            log.error("No notification targets configured.")
+            sys.exit(1)
+        notifier.send("Test notification", "info")
+        return
+
+    if args.monitor:
+        monitor_routes(args.refresh, notifier)
+        return
+
+    if args.list:
+        console.print(create_route_table(get_routes()))
+        return
+
+    if (args.add or args.data or args.metric) and hasattr(os, "geteuid") and os.geteuid() != 0:
+        log.warning("Not running as root; route changes will likely fail.")
+
+    if args.add:
+        if not (args.gateway and args.interface):
+            log.error("--add requires -g GATEWAY and -i INTERFACE")
+            sys.exit(1)
+        if args.default:
+            dest, mask = "0.0.0.0", "0.0.0.0"
+        elif args.data:
+            try:
+                net = ipaddress.ip_network(args.data[0], strict=False)
+            except ValueError as e:
+                log.error("Invalid network '%s': %s", args.data[0], e)
+                sys.exit(1)
+            dest, mask = str(net.network_address), str(net.netmask)
+        else:
+            log.error("Provide DATA (CIDR) or use -d for default route")
+            sys.exit(1)
+        sys.exit(0 if route_action("add", dest, mask, args.gateway, args.interface,
+                                   str(args.met), notifier) else 1)
+
+    if args.data:
+        if args.data == ['c']:
+            try:
+                import clipboard
+            except ImportError:
+                log.error("Clipboard support missing: pip install 'routedel[clipboard]'")
+                sys.exit(1)
+            tokens = clipboard.paste().split()
+        else:
+            tokens = args.data
+        if len(tokens) in (8, 9):  # full row, optional leading index
+            e = parse_route_table(" ".join(tokens)).get(0)
+            if not e:
+                log.error("Could not parse route row")
+                sys.exit(1)
+            sys.exit(0 if delete_entry(e, notifier) else 1)
+        if len(tokens) == 4:  # legacy: X GW METRIC DEV
+            sys.exit(0 if delete_default(tokens[1], tokens[2], tokens[3], notifier) else 1)
+        log.error("Unsupported data format (%d tokens)", len(tokens))
+        sys.exit(1)
+
+    if args.metric:
+        matches = find_by_metric(get_routes(), args.metric)
+        if not matches:
+            log.error("No route found with metric %s", args.metric)
+            sys.exit(1)
+        to_delete = matches
+        if len(matches) > 1:
+            log.warning("Multiple routes found with metric %s:", args.metric)
+            for idx, e in matches:
+                print(f"  [{idx}] {e}")
+            q = input("Index to delete, 'a' = all, 'c' = cancel: ").strip().lower()
+            if q == 'c':
+                log.info("Operation cancelled.")
+                return
+            if q == 'a':
+                pass
+            elif q.isdigit() and any(m[0] == int(q) for m in matches):
+                to_delete = [m for m in matches if m[0] == int(q)]
+            else:
+                log.error("Invalid input, operation cancelled.")
+                sys.exit(1)
+        ok = [delete_entry(e, notifier) for _, e in to_delete]
+        sys.exit(0 if all(ok) else 1)
+
+    log.error("Invalid arguments. Provide route details, -m METRIC, -a, -l or --monitor.")
+    p.print_help()
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

routedel/display.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+
+# File: src/routedel/display.py
+# Author: Hadi Cahyadi <cumulus13@gmail.com>
+# Date: 2026-10-26
+# Description: Rich display and live monitor.
+# License: MIT
+
+"""Rich display and live monitor."""
+import signal
+import threading
+from datetime import datetime
+
+from rich.align import Align
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .notify import Notifier
+from .routes import COLS, Route, Routes, get_routes, is_default, prefixlen
+
+console = Console()
+
+
+def create_route_table(routes: Routes, title: str = "Current Routes") -> Table:
+    t = Table(title=title, title_style="bold magenta", expand=True, padding=(0, 1))
+    styles = [("Idx", "cyan", 3), ("Destination", "bold cyan", 15), ("Gateway", "bold yellow", 15),
+              ("Genmask", "bold blue", 15), ("Flags", "bold magenta", 5), ("Metric", "bold green", 6),
+              ("Ref", "bold red", 3), ("Use", "bold white", 3), ("Iface", "bold cyan", 8)]
+    for name, style, width in styles:
+        t.add_column(name, style=style, no_wrap=True, min_width=width)
+    for idx, e in routes.items():
+        t.add_row(f"[{'bold red' if is_default(e) else 'cyan'}]{idx}[/]", *(e.get(c, "") for c in COLS))
+    return t
+
+
+def create_monitor_layout(routes: Routes, last_update: str, interval: float, n_targets: int) -> Layout:
+    head = Text()
+    head.append("Route Monitor", style="bold magenta")
+    head.append(f" | {last_update} | refresh {interval}s | notify targets: {n_targets} | Ctrl+C to exit", style="dim")
+    ifaces = sorted({e["Iface"] for e in routes.values() if e.get("Iface")})
+    stats = Text()
+    stats.append(f"Routes: {len(routes)}", style="bold white")
+    stats.append(f" | Default: {sum(map(is_default, routes.values()))}", style="bold red")
+    stats.append(f" | Interfaces: {', '.join(ifaces)}", style="cyan")
+    layout = Layout()
+    layout.split_column(
+        Layout(Panel(Align.center(head), style="bold blue"), size=3),
+        Layout(create_route_table(routes, f"Routing Table ({len(routes)} routes)")),
+        Layout(Panel(Align.center(stats), title="Statistics", style="dim"), size=3),
+    )
+    return layout
+
+
+def route_key(e: Route) -> tuple[str, ...]:
+    return tuple(e.get(c, "") for c in ("Destination", "Gateway", "Genmask", "Metric", "Iface"))
+
+
+def fmt_key(k: tuple[str, ...]) -> str:
+    d, g, m, met, i = k
+    return f"{d}/{prefixlen(m)} via {g} dev {i} metric {met}"
+
+
+def diff_routes(prev: dict, cur: dict):
+    """Return (message_lines, default_changed) for two {key: route} maps; ([], False) if equal."""
+    added, removed = cur.keys() - prev.keys(), prev.keys() - cur.keys()
+    if not (added or removed):
+        return [], False
+    lines = [f"+ {fmt_key(k)}" for k in sorted(added)] + [f"- {fmt_key(k)}" for k in sorted(removed)]
+    if len(lines) > 10:
+        lines = lines[:10] + [f"... +{len(lines) - 10} more"]
+    dflt = any(k[0] == "0.0.0.0" and k[2] == "0.0.0.0" for k in added | removed)
+    return lines, dflt
+
+
+def monitor_routes(interval: float, notifier: Notifier):
+    stop = threading.Event()
+    handler = lambda s, f: stop.set()
+    for name in ("SIGINT", "SIGTERM", "SIGHUP"):
+        if hasattr(signal, name):
+            signal.signal(getattr(signal, name), handler)
+
+    prev = {route_key(e): e for e in get_routes().values()}
+    notifier.send(f"Monitor started ({len(prev)} routes)", "info", wait=False)
+    try:
+        with Live(console=console, screen=True, auto_refresh=False) as live:
+            while not stop.is_set():
+                try:
+                    routes = get_routes()
+                    cur = {route_key(e): e for e in routes.values()}
+                    lines, dflt = diff_routes(prev, cur)
+                    if lines:
+                        notifier.send("Routing table changed:\n" + "\n".join(lines),
+                                      "warning" if dflt else "info", wait=False)
+                        prev = cur
+                    live.update(create_monitor_layout(routes, datetime.now().strftime("%H:%M:%S"),
+                                                      interval, len(notifier.targets)))
+                    live.refresh()
+                except Exception as e: # noqa
+                    live.update(Panel(Align.center(Text(f"Error: {e}\nRetrying in {interval}s", style="bold red")),
+                                      title="Error", style="bold red"))
+                    live.refresh()
+                stop.wait(interval)
+    finally:
+        notifier.send("Monitor stopped", "info", wait=True)
+        console.print("[green]Route monitoring stopped.[/green]")

routedel/notify.py

@@ -0,0 +1,137 @@
+"""ntfy (HTTP) and Growl (GNTP 1.0) notifications. Stdlib only. Multiple servers, sent in parallel."""
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import logging
+import os
+import re
+import socket
+import sys
+import threading
+import urllib.request
+from pathlib import Path
+
+APP_NAME = "routedel"
+HOST = socket.gethostname()
+log = logging.getLogger(APP_NAME)
+
+
+def _ntfy_send(cfg: dict, title: str, message: str, level: str):
+    url = cfg["url"].rstrip("/")
+    if cfg.get("topic"):
+        url = f"{url}/{cfg['topic']}"
+    headers = {
+        "Title": title.encode("ascii", "replace").decode(),
+        "Priority": {"info": "3", "warning": "4", "error": "5"}.get(level, "3"),
+        "Tags": {"info": "information_source", "warning": "warning", "error": "rotating_light"}.get(level, ""),
+    }
+    if cfg.get("token"):
+        headers["Authorization"] = f"Bearer {cfg['token']}"
+    elif cfg.get("user"):
+        cred = base64.b64encode(f"{cfg['user']}:{cfg.get('password', '')}".encode()).decode()
+        headers["Authorization"] = f"Basic {cred}"
+    req = urllib.request.Request(url, data=message.encode("utf-8"), headers=headers, method="POST")
+    with urllib.request.urlopen(req, timeout=cfg.get("timeout", 5)) as r:
+        if r.status >= 300:
+            raise RuntimeError(f"HTTP {r.status}")
+
+
+def _gntp_header(msg_type: str, password: str, algo: str = "SHA256") -> str:
+    if not password:
+        return f"GNTP/1.0 {msg_type} NONE\r\n"
+    salt = os.urandom(16)
+    key = hashlib.new(algo.lower(), password.encode("utf-8") + salt).digest()
+    key_hash = hashlib.new(algo.lower(), key).hexdigest().upper()
+    return f"GNTP/1.0 {msg_type} NONE {algo}:{key_hash}.{salt.hex().upper()}\r\n"
+
+
+def _gntp_roundtrip(host: str, port: int, payload: str, timeout: float):
+    with socket.create_connection((host, port), timeout=timeout) as s:
+        s.sendall(payload.encode("utf-8"))
+        buf = b""
+        while b"\r\n\r\n" not in buf:
+            chunk = s.recv(4096)
+            if not chunk:
+                break
+            buf += chunk
+    text = buf.decode("utf-8", "replace")
+    if "-OK" not in text.split("\r\n", 1)[0]:
+        raise RuntimeError(text.strip().replace("\r\n", " | ") or "empty response")
+
+
+def _gntp_send(cfg: dict, title: str, message: str, level: str):
+    host, port = cfg["host"], int(cfg.get("port", 23053))
+    pw, timeout = cfg.get("password", ""), cfg.get("timeout", 5)
+    one = lambda s: re.sub(r"[\r\n]+", "; ", str(s))  # GNTP values are single-line
+
+    reg = (_gntp_header("REGISTER", pw)
+           + f"Application-Name: {APP_NAME}\r\nNotifications-Count: 1\r\n\r\n"
+           + "Notification-Name: route-event\r\nNotification-Display-Name: Route Event\r\n"
+           + "Notification-Enabled: True\r\n\r\n")
+    _gntp_roundtrip(host, port, reg, timeout)
+
+    prio = {"info": 0, "warning": 1, "error": 2}.get(level, 0)
+    note = (_gntp_header("NOTIFY", pw)
+            + f"Application-Name: {APP_NAME}\r\nNotification-Name: route-event\r\n"
+            + f"Notification-Title: {one(title)}\r\nNotification-Text: {one(message)}\r\n"
+            + f"Notification-Priority: {prio}\r\n\r\n")
+    _gntp_roundtrip(host, port, note, timeout)
+
+
+class Notifier:
+    def __init__(self, ntfy: list[dict], growl: list[dict]):
+        self.targets: list[tuple[str, dict]] = [("ntfy", c) for c in ntfy] + [("growl", c) for c in growl]
+
+    def __bool__(self):
+        return bool(self.targets)
+
+    @staticmethod
+    def _one(kind: str, cfg: dict, title: str, msg: str, level: str):
+        label = cfg.get("url") if kind == "ntfy" else f"{cfg.get('host')}:{cfg.get('port', 23053)}"
+        try:
+            (_ntfy_send if kind == "ntfy" else _gntp_send)(cfg, title, msg, level)
+            log.info("[%s] sent -> %s", kind, label)
+        except Exception as e: # noqa
+            log.error("[%s] failed -> %s: %s", kind, label, e)
+
+    def send(self, message: str, level: str = "info", wait: bool = True, title: str | None = None):
+        if not self.targets:
+            return
+        title = title or f"{APP_NAME}@{HOST}"
+        threads = [threading.Thread(target=self._one, args=(k, c, title, message, level), daemon=True)
+                   for k, c in self.targets]
+        for t in threads:
+            t.start()
+        if wait:
+            for t in threads:
+                t.join(timeout=15)
+
+
+def load_config(path: str | None) -> dict:
+    candidates = [path, os.environ.get("ROUTEDEL_CONFIG"),
+                  str(Path.home() / ".config/routedel/config.json"), str(Path.home() / ".routedel.json")]
+    for p in filter(None, candidates):
+        if Path(p).is_file():
+            try:
+                return json.loads(Path(p).read_text(encoding="utf-8"))
+            except Exception as e: # noqa
+                log.error("Bad config %s: %s", p, e)
+                sys.exit(1)
+    return {}
+
+
+def build_notifier(no_notify: bool = False, config: str | None = None,
+                   ntfy_urls: list[str] | None = None, growl_hosts: list[str] | None = None) -> Notifier:
+    if no_notify:
+        return Notifier([], [])
+    cfg = load_config(config)
+    ntfy, growl = list(cfg.get("ntfy", [])), list(cfg.get("growl", []))
+    for u in ntfy_urls or []:  # https://host/topic
+        base, _, topic = u.rstrip("/").rpartition("/")
+        ntfy.append({"url": base, "topic": topic})
+    for g in growl_hosts or []:  # host[:port]
+        host, _, port = g.partition(":")
+        growl.append({"host": host, "port": int(port or 23053)})
+    return Notifier(ntfy, growl)

routedel/routes.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+# File: src/routedel/routes.py
+# Author: Hadi Cahyadi <cumulus13@gmail.com>
+# Date: 2026-10-26
+# Description: Route table reading, parsing and modification (Linux `ip` / `route`).
+# License: MIT
+
+"""Route table reading, parsing and modification (Linux `ip` / `route`)."""
+import ipaddress
+import logging
+import re
+import shutil
+import subprocess
+from typing import Any
+
+from .notify import Notifier
+
+log = logging.getLogger("routedel")
+
+Route = dict[str, str]
+Routes = dict[int, Route]
+COLS = ["Destination", "Gateway", "Genmask", "Flags", "Metric", "Ref", "Use", "Iface"]
+
+
+def netmask(prefix: int) -> str:
+    return str(ipaddress.ip_network(f"0.0.0.0/{prefix}").netmask)
+
+
+def prefixlen(mask: str) -> int:
+    return ipaddress.ip_network(f"0.0.0.0/{mask}").prefixlen
+
+
+def is_default(r: Route) -> bool:
+    return r.get("Destination") == "0.0.0.0" and r.get("Genmask") == "0.0.0.0"
+
+
+def parse_route_table(text: str) -> Routes:
+    """Parse `route -n` style text (optional leading '#' / index column)."""
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    hdr = next((i for i, ln in enumerate(lines) if "Destination" in ln and "Gateway" in ln), None)
+    out: Routes = {}
+    for ln in (lines[hdr + 1:] if hdr is not None else lines):
+        parts = re.sub(r"^\s*#\s*", "", ln).split()
+        if len(parts) == len(COLS) + 1 and parts[0].isdigit():
+            parts = parts[1:]
+        if len(parts) != len(COLS):
+            continue
+        out[len(out)] = dict(zip(COLS, parts))
+    return out
+
+
+def parse_ip_route(text: str) -> Routes:
+    """Parse `ip -4 route show` output into the same shape as parse_route_table."""
+    out: Routes = {}
+    for ln in text.splitlines():
+        p = ln.split()
+        if not p or p[0] in ("blackhole", "unreachable", "prohibit", "throw"):
+            continue
+        dest = p[0]
+        kv = {p[i]: p[i + 1] for i in range(len(p) - 1) if p[i] in ("via", "dev", "metric")}
+        try:
+            if dest == "default":
+                dest_ip, mask = "0.0.0.0", "0.0.0.0"
+            elif "/" in dest:
+                ip, pre = dest.split("/")
+                dest_ip, mask = ip, netmask(int(pre))
+            else:
+                dest_ip, mask = dest, "255.255.255.255"
+            ipaddress.ip_address(dest_ip)
+        except ValueError:
+            continue
+        out[len(out)] = {"Destination": dest_ip, "Gateway": kv.get("via", "0.0.0.0"), "Genmask": mask,
+                         "Flags": "UG" if "via" in kv else "U", "Metric": kv.get("metric", "0"),
+                         "Ref": "0", "Use": "0", "Iface": kv.get("dev", "")}
+    return out
+
+
+def get_routes() -> Routes:
+    try:
+        if shutil.which("ip"):
+            p = subprocess.run(["ip", "-4", "route", "show"], capture_output=True, text=True) # noqa
+            if p.returncode == 0:
+                return parse_ip_route(p.stdout)
+        if shutil.which("route"):
+            p = subprocess.run(["route", "-n"], capture_output=True, text=True) # noqa
+            return parse_route_table(p.stdout)
+    except Exception as e: # noqa
+        log.error("Failed to read routes: %s", e)
+    return {}
+
+
+def find_by_metric(data: Routes, metric: Any) -> list[tuple[int, Route]]:
+    return [(k, e) for k, e in data.items() if str(e.get("Metric", "")) == str(metric)]
+
+
+def _run(cmd: list[str]) -> tuple[bool, str]:
+    p = subprocess.run(cmd, capture_output=True, text=True) # noqa
+    return p.returncode == 0, (p.stderr or p.stdout).strip()
+
+
+def build_cmd(action: str, dest: str, mask: str, gw: str, iface: str, metric: str) -> list[str]:
+    """Build the add/del command. action: 'add' | 'del'."""
+    has_gw = gw not in ("", "0.0.0.0")
+    has_metric = metric not in ("", "0", None)
+    default = dest == "0.0.0.0" and mask == "0.0.0.0"
+    if shutil.which("ip"):
+        cmd = ["ip", "route", action, "default" if default else f"{dest}/{prefixlen(mask)}"]
+        if has_gw:
+            cmd += ["via", gw]
+        cmd += ["dev", iface]
+        if has_metric:
+            cmd += ["metric", str(metric)]
+        return cmd
+    cmd = ["route", action]
+    cmd += ["default"] if default else ["-net", dest, "netmask", mask]
+    if has_gw:
+        cmd += ["gw", gw]
+    if has_metric:
+        cmd += ["metric", str(metric)]
+    return cmd + ["dev", iface]
+
+
+def route_action(action: str, dest: str, mask: str, gw: str, iface: str, metric: str,
+                 notifier: Notifier) -> bool:
+    desc = f"{dest}/{prefixlen(mask)} via {gw} dev {iface} metric {metric or 0}"
+    cmd = build_cmd(action, dest, mask, gw, iface, metric)
+    log.warning("%s: %s", action, " ".join(cmd))
+    ok, msg = _run(cmd)
+    verb = "added" if action == "add" else "deleted"
+    if ok:
+        log.info("Route %s: %s", verb, desc)
+        notifier.send(f"Route {verb}: {desc}", "info")
+    else:
+        log.error("Failed to %s route: %s", action, msg)
+        notifier.send(f"FAILED to {action} route: {desc}\n{msg}", "error")
+    return ok
+
+
+def delete_entry(e: Route, notifier: Notifier) -> bool:
+    if not e.get("Iface"):
+        log.error("Entry missing Iface, skipping: %s", e)
+        return False
+    return route_action("del", e["Destination"], e["Genmask"], e["Gateway"], e["Iface"], e["Metric"], notifier)
+
+
+def delete_default(gw: str, metric: str, iface: str, notifier: Notifier) -> bool:
+    return route_action("del", "0.0.0.0", "0.0.0.0", gw, iface, metric, notifier)

routedel-1.0.3.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.5
+Name: routedel
+Version: 1.0.3
+Summary: Delete, add, list and monitor IPv4 routes, with ntfy and Growl (GNTP) notifications to multiple servers.
+Project-URL: Homepage, https://github.com/cumulus13/routedel
+Project-URL: Issues, https://github.com/cumulus13/routedel/issues
+Author-email: Hadi Cahyadi <cumulus13@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: cli,gntp,growl,monitor,network,ntfy,route,routing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Requires-Dist: rchf
+Requires-Dist: rich>=13.0
+Requires-Dist: richcolorlog
+Provides-Extra: clipboard
+Requires-Dist: clipboard; extra == 'clipboard'
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# routedel
+
+Delete, add, list and monitor IPv4 routes on Linux, with notifications to **multiple ntfy and Growl (GNTP) servers**.
+
+## Install
+
+```bash
+pip install routedel
+pip install "routedel[clipboard]"   # optional: read route rows from the clipboard
+```
+
+## Usage
+
+```bash
+routedel -l                                    # list routes
+routedel -m 100                                # delete route(s) by metric
+routedel 0.0.0.0 192.168.1.1 0.0.0.0 UG 100 0 0 eth0   # delete a full `route -n` row
+routedel 0.0.0.0 192.168.1.1 100 eth0          # legacy: X GW METRIC DEV (default route)
+routedel c                                     # delete using a route row from the clipboard
+sudo routedel -a 10.0.0.0/8 -g 192.168.1.1 -i eth0 --met 50   # add route
+sudo routedel -a -d -g 192.168.1.1 -i eth0 --met 100          # add default route
+routedel --monitor --refresh 2                 # live monitor, notifies on changes
+```
+
+Route changes need root.
+
+## Notifications
+
+Any number of servers of each type. Via CLI (repeatable):
+
+```bash
+routedel -m 100 --ntfy https://ntfy.sh/my-routes --ntfy https://ntfy.example.com/alerts \
+                --growl 192.168.1.10 --growl 192.168.1.20:23053
+```
+
+Or via a JSON config (first found wins): `--config FILE`, `$ROUTEDEL_CONFIG`,
+`~/.config/routedel/config.json`, `~/.routedel.json`. CLI targets are added to the config targets.
+
+```json
+{
+  "ntfy":  [{"url": "https://ntfy.sh", "topic": "my-routes", "token": "tk_xxx"},
+            {"url": "https://ntfy.example.com", "topic": "alerts", "user": "u", "password": "p"}],
+  "growl": [{"host": "192.168.1.10", "port": 23053, "password": "secret"},
+            {"host": "192.168.1.20"}]
+}
+```
+
+Test with `routedel --test-notify`. Disable with `--no-notify`.
+Servers are contacted in parallel; one failing server does not affect the others.
+Dependencies for notifications: none (stdlib `urllib` + raw GNTP 1.0 over sockets).
+
+## License
+
+MIT
+
+## Development & release
+
+```bash
+pip install -e ".[dev]" && pytest
+python -m build && twine check dist/*
+```
+
+Release to PyPI (GitHub Actions, Trusted Publishing — no token needed):
+
+1. On pypi.org → *Publishing* → add a pending publisher: owner `cumulus13`, repo `routedel`,
+   workflow `publish.yml`, environment `pypi`. (Repeat on test.pypi.org with environment `testpypi` if wanted.)
+2. In the GitHub repo create environments `pypi` (and `testpypi`).
+3. Bump `version` in `pyproject.toml` and `src/routedel/__init__.py`, commit, then publish a
+   GitHub Release tagged `vX.Y.Z`. The workflow tests, checks tag == version, builds and uploads.
+
+Manual alternative: `twine upload dist/*` (API token).
+
+## 👤 Author
+        
+[Hadi Cahyadi](mailto:cumulus13@gmail.com)
+    
+
+[![Buy Me a Coffee](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/cumulus13)
+
+[![Donate via Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/cumulus13)
+ 
+[Support me on Patreon](https://www.patreon.com/cumulus13)

routedel-1.0.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+routedel/__init__.py,sha256=PjvpmQ3ltXOSyRuWe5k7Lfy9PbUex09TZNae7u9YKiI,352
+routedel/__main__.py,sha256=Y2Gbd0_Q-ijV93xOzfeJz1MAlsn_wi2PKrA80Wkxias,214
+routedel/cli.py,sha256=h5_c9GCaXyjQ8Ju7BV1ojuiQ40CzbBfJ8j6PT3yELo0,5970
+routedel/display.py,sha256=Spmwcq7bC-8aR4i0oauAHK3H2Sv67jeJC-h2zBWB6rE,4710
+routedel/notify.py,sha256=t_lXt99ihP7tYhxJODhNMSIIVgWHT7iScNP2ZEtONVA,5558
+routedel/routes.py,sha256=oG2CRFwHQ3k6FbrfxqyA1e8xk0lSpFjLOZboFSvspeo,5419
+routedel-1.0.3.dist-info/METADATA,sha256=TLhwKfNOu3OSyhq-YEF6lgT4pZVY-GgXYzunI9UZ3TA,4115
+routedel-1.0.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+routedel-1.0.3.dist-info/entry_points.txt,sha256=ruBy7nibv9uhgWVktVFlbi636ljyG2QarpUXHEkW4lY,47
+routedel-1.0.3.dist-info/licenses/LICENSE,sha256=IVqSwOi6obYt2Sixm_KTFYa3kf4P7IQM8Y8fHC_huvg,1069
+routedel-1.0.3.dist-info/RECORD,,

routedel-1.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

routedel-1.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+routedel = routedel.cli:main

routedel-1.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hadi Cahyadi
+
+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.