ndVpi 1.0.0b0__py3-none-any.whl

ndvpi/__init__.py

@@ -0,0 +1,27 @@
+"""ndVpi — фоновая оптимизация сети и сканер Wi-Fi."""
+from .version import __version__
+from .wifi import WiFiScanner
+from .network_info import NetworkInfo
+from .polidium import Polidium
+from .critchers import Critchers
+from .network_config import NetworkConfig
+from .monitor import NetworkMonitor
+from .diagnostics import NetworkDiagnostics
+from .history import SessionHistory
+
+__all__ = [
+    "__version__",
+    "WiFiScanner",
+    "NetworkInfo",
+    "Polidium",
+    "Critchers",
+    "NetworkConfig",
+    "NetworkMonitor",
+    "NetworkDiagnostics",
+    "SessionHistory",
+]
+
+try:
+    from . import collquan_ext  # noqa: F401
+except Exception:
+    pass

ndvpi/charm_enhance.py

@@ -0,0 +1,136 @@
+"""Мягкая интеграция с CharmPkk: красиво, если есть; обычно, если нет."""
+import sys
+
+_charm = None
+_c = None
+_available = False
+
+try:
+    from charmpkk import console as _c
+    _charm = __import__("charmpkk")
+    _available = True
+except Exception:
+    _available = False
+
+def has_charm(): return _available
+def console(): return _c
+def theme(name="tokyo_night"): return _c.get_theme(name) if _available else None
+
+def _fg(color):
+    if not _available or not color: return None
+    if isinstance(color, str) and color.startswith("#"): return _c.fg_hex(color)
+    return color
+
+def print_msg(text, color=None, style=None):
+    print(_c.colorize(text, fg=_fg(color), style=style)) if _available else print(text)
+
+def banner(title, subtitle=None, color="#7aa2ff"):
+    if _available: return _c.banner(title, subtitle, fg=_fg(color))
+    return f"\n=== {title} ===\n{subtitle}\n" if subtitle else f"\n=== {title} ===\n"
+
+def box(content, title=None, color="#7aa2ff"):
+    if _available: return _c.box(content, title=title, border_fg=_fg(color))
+    lines = content if isinstance(content, list) else [content]
+    return "\n".join([f"--- {title} ---" if title else "-"*20] + [str(l) for l in lines] + ["-"*20])
+
+def table(headers, rows, header_color="#7aa2ff"):
+    if _available: return _c.Table(headers=headers, rows=rows, header_fg=_fg(header_color)).render()
+    all_rows = [list(headers)] + [list(r) for r in rows]
+    n_cols = len(headers)
+    widths = [max(len(str(r[i])) if i < len(r) else 0 for r in all_rows) for i in range(n_cols)]
+    lines = []
+    for i, row in enumerate(all_rows):
+        cells = [str(row[j]) if j < len(row) else "" for j in range(n_cols)]
+        lines.append(" | ".join(c.ljust(widths[j]) for j, c in enumerate(cells)))
+        if i == 0: lines.append("-+-".join("-" * w for w in widths))
+    return "\n".join(lines)
+
+def sparkline(values, fg="#7aa2ff"):
+    if _available: return _c.sparkline(values, fg=_fg(fg))
+    return "".join("▁▂▃▄▅▆▇█"[int(v/max(values or [1])*(7))] for v in values)
+
+def key_value(data, key_color="#8b93a7"):
+    if _available: return _c.key_value(data, key_fg=_fg(key_color))
+    max_k = max((len(str(k)) for k in data), default=0)
+    return "\n".join(f"  {str(k).ljust(max_k)}: {v}" for k, v in data.items())
+
+def info(msg): print(_c.info(msg)) if _available else print(f"[i] {msg}")
+def success(msg): print(_c.success(msg)) if _available else print(f"[+] {msg}")
+def warning(msg): print(_c.warning(msg)) if _available else print(f"[!] {msg}")
+def error(msg): print(_c.error(msg)) if _available else print(f"[x] {msg}")
+
+def render_info(msg): return _c.info(msg) if _available else f"[i] {msg}"
+def render_success(msg): return _c.success(msg) if _available else f"[+] {msg}"
+def render_warning(msg): return _c.warning(msg) if _available else f"[!] {msg}"
+def render_error(msg): return _c.error(msg) if _available else f"[x] {msg}"
+
+def ask(prompt, default=None):
+    if _available: return _c.ask(prompt, default=default)
+    hint = f" [{default}]" if default is not None else ""
+    try: return input(f"? {prompt}{hint}: ").strip() or default
+    except (EOFError, KeyboardInterrupt): return default
+
+def confirm(prompt, default=False):
+    if _available: return _c.confirm(prompt, default=default)
+    d = "Y/n" if default else "y/N"
+    try: v = input(f"? {prompt} ({d}): ").strip().lower()
+    except (EOFError, KeyboardInterrupt): return default
+    return v.startswith("y") if v else default
+
+def select(title, options, color="#7aa2ff"):
+    if not options: return None
+    if _available: return _c.select(title, options, fg_cursor=_fg(color), fg_title=_fg(color))
+    print(title)
+    for i, opt in enumerate(options, 1): print(f"  {i}. {opt}")
+    try:
+        idx = int(input("> ").strip()) - 1
+        if 0 <= idx < len(options): return options[idx]
+    except Exception: return None
+
+class _NullProgress:
+    def __enter__(self): return self
+    def __exit__(self, *exc): print()
+    def update(self, current): sys.stdout.write(f"\r  {current}%"); sys.stdout.flush()
+    def finish(self, msg=None): print(msg) if msg else None
+
+def progress(total=100, label="", color="#7aa2ff"):
+    return _c.FancyProgressBar(total=total, label=label, fg=_fg(color)) if _available else _NullProgress()
+
+class _NullSpinner:
+    def __enter__(self): return self
+    def __exit__(self, *exc): pass
+    def stop(self, final=None): print(final) if final else None
+
+def spinner(text="Loading", color="#7aa2ff"):
+    if _available: return _c.Spinner(text, fg=_fg(color))
+    print(text + "...")
+    return _NullSpinner()
+
+class LiveDashboard:
+    def __init__(self):
+        self._live = None
+        self._running = False
+        self._last_lines = 0
+    def __enter__(self):
+        if _available: self._live = _c.Live(); self._live.__enter__()
+        self._running = True
+        return self
+    def update(self, content):
+        if not self._running: return
+        if _available and self._live: self._live.update(content)
+        else:
+            lines = content.split("\n")
+            if self._last_lines > 0: sys.stdout.write(f"\033[{self._last_lines}A")
+            max_lines = max(self._last_lines, len(lines))
+            for i in range(max_lines):
+                sys.stdout.write("\033[2K")
+                if i < len(lines): sys.stdout.write(lines[i])
+                sys.stdout.write("\n")
+            if max_lines > len(lines): sys.stdout.write(f"\033[{max_lines - len(lines)}A")
+            self._last_lines = len(lines)
+            sys.stdout.flush()
+    def __exit__(self, *exc):
+        self._running = False
+        if _available and self._live: self._live.__exit__(*exc)
+        else: sys.stdout.write("\n")
+        return False

ndvpi/cli.py

@@ -0,0 +1,13 @@
+"""CLI для ndVpi."""
+import sys
+
+def main():
+    from .menu import run
+    try:
+        return run()
+    except KeyboardInterrupt:
+        print()
+        return 130
+
+if __name__ == "__main__":
+    sys.exit(main())

ndvpi/collquan_ext.py

@@ -0,0 +1,111 @@
+"""Интеграция ndVpi с Collquan (CharmPkk)."""
+try:
+    from charmpkk.terminals import CollquanShell
+except Exception:
+    CollquanShell = None
+
+from .wifi import WiFiScanner
+from .network_info import NetworkInfo
+from .polidium import Polidium
+from .critchers import Critchers
+from .network_config import NetworkConfig, _is_admin
+
+_polidium = Polidium()
+_critchers = Critchers()
+_config = NetworkConfig()
+
+def _cmd_scan(args):
+    data = WiFiScanner().current_network()
+    if not data: print("Нет данных о Wi-Fi."); return
+    for k, v in data.items(): print(f"{k}: {v}")
+
+def _cmd_info(args):
+    info = NetworkInfo()
+    print(f"IP:    {info.local_ip()}")
+    print(f"Шлюз:  {info.gateway()}")
+    print(f"DNS:   {', '.join(info.dns_servers()) or '—'}")
+    print(f"Ping:  {info.ping() or '—'} ms")
+
+def _cmd_poli(args):
+    if args and args[0] == "dns":
+        _polidium.flush_dns()
+        print("[+] DNS кэш очищен")
+    elif args and args[0] == "arp":
+        _polidium.flush_arp()
+        print("[+] ARP кэш очищен")
+    else:
+        _polidium.flush_dns()
+        _polidium.flush_arp()
+        print("[+] Polidium: кэши очищены")
+        
+def _cmd_crit(args):
+    if args and args[0] == "ram":
+        ok, msg = _critchers.clean_standby_list()
+        print(f"[{'x' if not ok else '+'}] {msg}")
+    elif args and args[0] == "tcp":
+        ok, msg = _critchers.apply_tcp_tweaks()
+        print(f"[{'x' if not ok else '+'}] {msg}")
+    elif args and args[0] == "restore":
+        ok, msg = _critchers.restore()
+        print(f"[{'x' if not ok else '+'}] {msg}")
+    else:
+        print("Использование: ndcrit <ram|tcp|restore>")
+
+def _cmd_dns(args):
+    if not args or args[0] == "show":
+        servers = _config.get_dns()
+        print("DNS:", ", ".join(servers) if servers else "автоматически")
+        return
+    if args[0] == "set":
+        if len(args) < 2: print("Использование: nddns set <ip1> [ip2]..."); return
+        ok, msg = _config.set_dns(args[1:])
+        print(("[+] " if ok else "[x] ") + msg)
+        return
+    if args[0] == "reset":
+        ok, msg = _config.reset_dns()
+        print(("[+] " if ok else "[x] ") + msg)
+        return
+    print("Использование: nddns [show|set <ip>...|reset]")
+
+def _cmd_pass(args):
+    if len(args) < 2: print("Использование: ndpass <ssid> <new_password>"); return
+    ssid, pwd = args[0], args[1]
+    print(f"[!] Внимание: смена пароля для '{ssid}' может разорвать соединение.")
+    if input("Продолжить? [y/N] ").strip().lower() != "y":
+        print("Отменено."); return
+    ok, msg = _config.change_wifi_password(ssid, pwd)
+    print(("[+] " if ok else "[x] ") + msg)
+
+def _cmd_adapters(args):
+    if not args or args[0] == "list":
+        for a in _config.list_adapters(): print(f"  {a.get('name', '?'):<30} {a}")
+        return
+    if args[0] in ("enable", "disable") and len(args) >= 2:
+        ok, msg = _config.set_adapter_state(args[1], enabled=(args[0] == "enable"))
+        print(("[+] " if ok else "[x] ") + msg)
+        return
+    print("Использование: ndadapters [list|enable|disable <name>]")
+
+def _cmd_mtu(args):
+    if not args: print("Использование: ndmtu <interface> [new_mtu]"); return
+    iface = args[0]
+    if len(args) == 1:
+        mtu = _config.get_mtu(iface)
+        print(f"MTU {iface} = {mtu if mtu is not None else '—'}")
+        return
+    ok, msg = _config.set_mtu(iface, args[1])
+    print(("[+] " if ok else "[x] ") + msg)
+
+def _cmd_admin(args):
+    print("Администратор:", "да" if _is_admin() else "нет")
+
+if CollquanShell is not None:
+    CollquanShell.register("ndscan", "Сканировать Wi-Fi")(_cmd_scan)
+    CollquanShell.register("ndinfo", "Информация о сети")(_cmd_info)
+    CollquanShell.register("ndpoli", "Polidium: очистка DNS/ARP")(_cmd_poli)
+    CollquanShell.register("ndcrit", "Critchers: RAM/TCP буст")(_cmd_crit)
+    CollquanShell.register("nddns", "DNS: show/set/reset")(_cmd_dns)
+    CollquanShell.register("ndpass", "Сменить пароль Wi-Fi: <ssid> <pass>")(_cmd_pass)
+    CollquanShell.register("ndadapters", "Адаптеры: list/enable/disable")(_cmd_adapters)
+    CollquanShell.register("ndmtu", "MTU: <iface> [new_mtu]")(_cmd_mtu)
+    CollquanShell.register("ndadmin", "Проверить права администратора")(_cmd_admin)

ndvpi/critchers.py

@@ -0,0 +1,184 @@
+"""Critchers: Агрессивный сетевой бустер и очистка ресурсов (Без psutil)."""
+import os
+import sys
+import json
+import ctypes
+import platform
+import subprocess
+import atexit
+from pathlib import Path
+
+BACKUP_FILE = Path.home() / ".ndvpi" / "critchers_backup.json"
+
+def _is_windows():
+    return platform.system() == "Windows"
+
+def _is_admin():
+    if not _is_windows(): return False
+    try:
+        return ctypes.windll.shell32.IsUserAnAdmin() != 0
+    except Exception:
+        return False
+
+def _get_pids(process_name):
+    try:
+        cmd = f'tasklist /FI "IMAGENAME eq {process_name}" /FO CSV /NH'
+        out = subprocess.run(cmd, shell=True, capture_output=True, text=True, encoding="cp866").stdout
+        pids = []
+        for line in out.splitlines():
+            if process_name.lower() in line.lower():
+                parts = line.split('","')
+                if len(parts) > 1:
+                    try: pids.append(int(parts[1]))
+                    except ValueError: pass
+        return pids
+    except Exception:
+        return []
+
+def _suspend_process(pid):
+    try:
+        PROCESS_SUSPEND_RESUME = 0x0800
+        handle = ctypes.windll.kernel32.OpenProcess(PROCESS_SUSPEND_RESUME, False, pid)
+        if handle:
+            ctypes.windll.ntdll.NtSuspendProcess(handle)
+            ctypes.windll.kernel32.CloseHandle(handle)
+            return True
+    except Exception:
+        pass
+    return False
+
+def _resume_process(pid):
+    try:
+        PROCESS_SUSPEND_RESUME = 0x0800
+        handle = ctypes.windll.kernel32.OpenProcess(PROCESS_SUSPEND_RESUME, False, pid)
+        if handle:
+            ctypes.windll.ntdll.NtResumeProcess(handle)
+            ctypes.windll.kernel32.CloseHandle(handle)
+            return True
+    except Exception:
+        pass
+    return False
+
+class Critchers:
+    def __init__(self):
+        self.backup_data = {}
+        self.suspended_pids = []
+        atexit.register(self.resume_background_downloads)
+        
+        if BACKUP_FILE.exists():
+            try:
+                self.backup_data = json.loads(BACKUP_FILE.read_text("utf-8"))
+            except Exception:
+                pass
+
+    def _save_backup(self):
+        BACKUP_FILE.parent.mkdir(parents=True, exist_ok=True)
+        BACKUP_FILE.write_text(json.dumps(self.backup_data, indent=2), "utf-8")
+
+    def clean_standby_list(self):
+        if not _is_windows() or not _is_admin():
+            return False, "Требуются права администратора Windows"
+        try:
+            ctypes.windll.ntdll.NtSetSystemInformation(-1073744922, ctypes.byref(ctypes.c_int(4)), 4)
+            return True, "RAM Standby List очищен"
+        except Exception as e:
+            return False, f"Ошибка RAM: {e}"
+
+    def apply_tcp_tweaks(self, dry_run=False):
+        if not _is_windows(): return False, "Только для Windows"
+        import winreg
+        tweaks = {
+            r"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters": {
+                "NetworkThrottlingIndex": 0xffffffff,
+                "TcpAckFrequency": 1,
+                "TCPNoDelay": 1,
+                "TcpDelAckTicks": 0
+            }
+        }
+        if dry_run:
+            return True, "DRY-RUN: Будет изменен реестр (TCP Acknowledgment, Throttling)"
+        if not _is_admin():
+            return False, "Требуются права администратора"
+        for path, values in tweaks.items():
+            try:
+                key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path, 0, winreg.KEY_ALL_ACCESS)
+                for name, val in values.items():
+                    try:
+                        orig_val, _ = winreg.QueryValueEx(key, name)
+                        self.backup_data[f"{path}\\{name}"] = orig_val
+                    except FileNotFoundError:
+                        self.backup_data[f"{path}\\{name}"] = None
+                    winreg.SetValueEx(key, name, 0, winreg.REG_DWORD, val)
+                winreg.CloseKey(key)
+            except Exception as e:
+                return False, f"Ошибка реестра: {e}"
+        self._save_backup()
+        return True, "Твики TCP успешно применены"
+
+    def disable_wifi_power_saving(self, dry_run=False):
+        if not _is_windows(): return False, "Только для Windows"
+        if dry_run: return True, "DRY-RUN: Отключение энергосбережения Wi-Fi адаптера"
+        if not _is_admin(): return False, "Требуются права администратора"
+        ps_cmd = (
+            'Get-NetAdapter | Where-Object {$_.PhysicalMediaType -match "Native 802.11"} '
+            '| Disable-NetAdapterPowerManagement -ErrorAction SilentlyContinue'
+        )
+        try:
+            subprocess.run(["powershell", "-NoProfile", "-Command", ps_cmd], capture_output=True)
+            return True, "Энергосбережение Wi-Fi отключено"
+        except Exception as e:
+            return False, f"Ошибка: {e}"
+
+    def pause_background_downloads(self):
+        if not _is_windows() or not _is_admin():
+            return False, "Требуются права администратора"
+        targets = ["OneDrive.exe", "wuauclt.exe", "SysMain.exe"]
+        paused = []
+        for proc_name in targets:
+            pids = _get_pids(proc_name)
+            for pid in pids:
+                if _suspend_process(pid):
+                    self.suspended_pids.append(pid)
+                    paused.append(f"{proc_name} (PID: {pid})")
+        if paused:
+            return True, f"Приостановлены процессы: {', '.join(paused)}"
+        return True, "Фоновые качалки не найдены (или уже спят)"
+
+    def resume_background_downloads(self):
+        if not self.suspended_pids: return
+        resumed = []
+        for pid in self.suspended_pids:
+            if _resume_process(pid):
+                resumed.append(str(pid))
+        self.suspended_pids = []
+        if resumed:
+            print(f"[Critchers] Возобновлены процессы: {', '.join(resumed)}")
+
+    def restore(self):
+        if not _is_windows() or not _is_admin():
+            return False, "Требуются права администратора"
+        import winreg
+        restored = 0
+        for full_key, orig_val in self.backup_data.items():
+            path, name = full_key.rsplit("\\", 1)
+            try:
+                key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path, 0, winreg.KEY_ALL_ACCESS)
+                if orig_val is None:
+                    try: winreg.DeleteValue(key, name)
+                    except FileNotFoundError: pass
+                else:
+                    winreg.SetValueEx(key, name, 0, winreg.REG_DWORD, orig_val)
+                winreg.CloseKey(key)
+                restored += 1
+            except Exception:
+                pass
+        self.backup_data = {}
+        if BACKUP_FILE.exists():
+            BACKUP_FILE.unlink()
+        ps_cmd = (
+            'Get-NetAdapter | Where-Object {$_.PhysicalMediaType -match "Native 802.11"} '
+            '| Enable-NetAdapterPowerManagement -ErrorAction SilentlyContinue'
+        )
+        subprocess.run(["powershell", "-NoProfile", "-Command", ps_cmd], capture_output=True)
+        self.resume_background_downloads()
+        return True, f"Восстановлено настроек: {restored}. Wi-Fi питание и процессы возвращены."

ndvpi/diagnostics.py

@@ -0,0 +1,75 @@
+"""Диагностика сети: выявление проблем и рекомендации."""
+import socket
+from .network_info import NetworkInfo
+from .wifi import WiFiScanner
+from .network_config import NetworkConfig
+from . import charm_enhance as ui
+
+class CheckResult:
+    def __init__(self, name, ok, details, recommendation=""):
+        self.name, self.ok, self.details, self.recommendation = name, ok, details, recommendation
+
+class NetworkDiagnostics:
+    def __init__(self):
+        self.info = NetworkInfo()
+        self.wifi = WiFiScanner()
+        self.config = NetworkConfig()
+
+    def run_checks(self):
+        results = []
+        adapters = self.config.list_adapters()
+        enabled = [a for a in adapters if a.get("state") in ("Connected", "Подключено", "up", "Подключен")]
+        if not adapters:
+            results.append(CheckResult("Адаптеры", False, "Не найдены сетевые адаптеры", "Проверьте драйверы"))
+        elif not enabled:
+            results.append(CheckResult("Адаптеры", False, "Все отключены", "Включите сетевой адаптер"))
+        else:
+            results.append(CheckResult("Адаптеры", True, f"Активен: {enabled[0].get('name', 'Неизвестно')}"))
+
+        wifi_data = self.wifi.current_network()
+        if wifi_data:
+            results.append(CheckResult("Wi-Fi", True, f"Подключено к {wifi_data.get('ssid', '?')}"))
+        else:
+            results.append(CheckResult("Wi-Fi", True, "Не активен (возможно Ethernet)"))
+
+        gw = self.info.gateway()
+        if not gw:
+            results.append(CheckResult("Шлюз", False, "Не найден", "Проверьте DHCP"))
+        else:
+            gw_ping = self.info.ping(gw, timeout=1)
+            if gw_ping is not None:
+                results.append(CheckResult("Шлюз", True, f"{gw} ({gw_ping:.0f} ms)"))
+            else:
+                results.append(CheckResult("Шлюз", False, f"{gw} не отвечает", "Перезагрузите роутер"))
+
+        try:
+            socket.gethostbyname("google.com")
+            results.append(CheckResult("DNS", True, "Разрешение имён работает"))
+        except socket.gaierror:
+            results.append(CheckResult("DNS", False, "Домены не резолвятся", "Смените DNS на 1.1.1.1"))
+
+        ping_stats = self.info.ping_series("8.8.8.8", count=3, timeout=1)
+        if not ping_stats:
+            results.append(CheckResult("Интернет", False, "Нет доступа", "Проверьте кабель/провайдера"))
+        else:
+            if ping_stats["loss"] > 0:
+                results.append(CheckResult("Потери", False, f"Потери: {ping_stats['loss']:.1f}%", "Помехи или перегрузка канала"))
+            elif ping_stats["avg"] > 150:
+                results.append(CheckResult("Пинг", False, f"Высокий: {ping_stats['avg']:.0f} ms", "Попробуйте Critchers или Polidium"))
+            else:
+                results.append(CheckResult("Интернет", True, f"Стабильно ({ping_stats['avg']:.0f} ms)"))
+        return results
+
+    def get_report(self):
+        results = self.run_checks()
+        fails = [r for r in results if not r.ok]
+        if ui.has_charm():
+            rows = [[("✔ OK" if r.ok else "✖ ОШИБКА"), r.name, r.details or "", r.recommendation or ""] for r in results]
+            out = [ui.table(["Статус", "Проверка", "Детали", "Рекомендация"], rows), ""]
+            out.append(ui.render_warning("Обнаружены проблемы.") if fails else ui.render_success("Сеть работает стабильно."))
+            return "\n".join(out)
+        out = ["=== Диагностика сети ==="]
+        for r in results:
+            out.append(f"{'[+]' if r.ok else '[x]'} {r.name}: {r.details}")
+            if not r.ok and r.recommendation: out.append(f"    -> {r.recommendation}")
+        return "\n".join(out)

ndvpi/history.py

@@ -0,0 +1,58 @@
+"""История метрик сети за сессию и экспорт в JSON/CSV."""
+import json
+import csv
+import time
+from pathlib import Path
+
+class SessionHistory:
+    def __init__(self):
+        self.records = []
+
+    def add_ping(self, host, stats):
+        if stats:
+            self.records.append({"ts": time.time(), "type": "ping", "host": host, "data": stats})
+
+    def add_speed(self, download_mbps, upload_mbps):
+        self.records.append({"ts": time.time(), "type": "speed", "data": {"download": download_mbps, "upload": upload_mbps}})
+
+    def clear(self):
+        self.records.clear()
+
+    def summary(self):
+        pings = [r for r in self.records if r["type"] == "ping"]
+        speeds = [r for r in self.records if r["type"] == "speed"]
+        result = {"samples": len(self.records)}
+        if pings:
+            result.update({
+                "avg_ping_ms": round(sum(p["data"]["avg"] for p in pings) / len(pings), 2),
+                "avg_loss_pct": round(sum(p["data"]["loss"] for p in pings) / len(pings), 2),
+                "avg_jitter_ms": round(sum(p["data"]["jitter"] for p in pings) / len(pings), 2)
+            })
+        if speeds:
+            result.update({
+                "avg_download_mbps": round(sum(s["data"]["download"] for s in speeds) / len(speeds), 2),
+                "avg_upload_mbps": round(sum(s["data"]["upload"] for s in speeds) / len(speeds), 2)
+            })
+        return result
+
+    def export_json(self, filepath):
+        path = Path(filepath)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.records, f, indent=2, ensure_ascii=False)
+        return str(path)
+
+    def export_csv(self, filepath):
+        path = Path(filepath)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["Timestamp", "Type", "Min/Avg/Download", "Max/Upload", "Loss/Jitter"])
+            for r in self.records:
+                if r["type"] == "ping":
+                    d = r["data"]
+                    writer.writerow([time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(r["ts"])), "Ping", f"{d['avg']:.1f} ms", f"{d['max']:.1f} ms", f"{d['loss']:.1f}% / {d['jitter']:.1f} ms"])
+                elif r["type"] == "speed":
+                    d = r["data"]
+                    writer.writerow([time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(r["ts"])), "Speed", f"{d['download']:.1f} Mbps", f"{d['upload']:.1f} Mbps", "-"])
+        return str(path)