ndVpi 1.100.0__py3-none-any.whl

ndvpi/__init__.py

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

ndvpi/charm_enhance.py

@@ -0,0 +1,279 @@
+"""Мягкая интеграция с 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"):
+    if not _available:
+        return None
+    return _c.get_theme(name)
+
+
+# ---------- Цветной вывод ----------
+
+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):
+    if _available:
+        print(_c.colorize(text, fg=_fg(color), style=style))
+    else:
+        print(text)
+
+
+def banner(title, subtitle=None, color="#7aa2ff"):
+    if _available:
+        return _c.banner(title, subtitle, fg=_fg(color))
+    if subtitle:
+        return f"\n=== {title} ===\n{subtitle}\n"
+    return 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]
+    header = f"--- {title} ---" if title else "-" * 20
+    return "\n".join([header] + [str(l) for l in lines] + ["-" * 20])
+
+
+def table(headers, rows, header_color="#7aa2ff"):
+    if _available:
+        t = _c.Table(headers=headers, rows=rows, header_fg=_fg(header_color))
+        return t.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 = []
+        for j in range(n_cols):
+            v = str(row[j]) if j < len(row) else ""
+            cells.append(v.ljust(widths[j]))
+        lines.append(" | ".join(cells))
+        if i == 0:
+            lines.append("-+-".join("-" * w for w in widths))
+    return "\n".join(lines)
+
+
+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())
+
+
+# ---------- Сообщения: печать (возвращают None) ----------
+
+def info(msg, color="#3b82f6"):
+    if _available:
+        print(_c.info(msg))
+    else:
+        print(f"[i] {msg}")
+
+
+def success(msg, color="#22c55e"):
+    if _available:
+        print(_c.success(msg))
+    else:
+        print(f"[+] {msg}")
+
+
+def warning(msg, color="#f59e0b"):
+    if _available:
+        print(_c.warning(msg))
+    else:
+        print(f"[!] {msg}")
+
+
+def error(msg, color="#ef4444"):
+    if _available:
+        print(_c.error(msg))
+    else:
+        print(f"[x] {msg}")
+
+
+# ---------- Сообщения: рендер (возвращают строку) ----------
+# Используйте эти версии, когда нужно встроить сообщение в составной текст
+# (например, в "\n".join(...)), а не печатать его сразу.
+
+def render_info(msg, color="#3b82f6"):
+    if _available:
+        return _c.info(msg)
+    return f"[i] {msg}"
+
+
+def render_success(msg, color="#22c55e"):
+    if _available:
+        return _c.success(msg)
+    return f"[+] {msg}"
+
+
+def render_warning(msg, color="#f59e0b"):
+    if _available:
+        return _c.warning(msg)
+    return f"[!] {msg}"
+
+
+def render_error(msg, color="#ef4444"):
+    if _available:
+        return _c.error(msg)
+    return 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:
+        v = input(f"? {prompt}{hint}: ").strip()
+        return v 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 (ValueError, EOFError, KeyboardInterrupt):
+        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):
+        if msg:
+            print(msg)
+
+
+def progress(total=100, label="", color="#7aa2ff"):
+    if _available:
+        return _c.FancyProgressBar(total=total, label=label, fg=_fg(color))
+    return _NullProgress()
+
+
+class _NullSpinner:
+    def __enter__(self):
+        print()
+        return self
+
+    def __exit__(self, *exc):
+        print()
+
+    def stop(self, final=None):
+        if final:
+            print(final)
+
+
+def spinner(text="Loading", color="#7aa2ff"):
+    if _available:
+        return _c.Spinner(text, fg=_fg(color))
+    print(text + "...")
+    return _NullSpinner()
+
+
+# ---------- Live Dashboard ----------
+
+class LiveDashboard:
+    """Живой дашборд. С CharmPkk использует Live, без него — ANSI-перерисовку."""
+
+    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,15 @@
+"""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,151 @@
+"""Интеграция ndVpi с Collquan (CharmPkk)."""
+try:
+    from charmpkk.terminals import CollquanShell
+except Exception:
+    CollquanShell = None
+
+from .wifi import WiFiScanner
+from .network_info import NetworkInfo
+from .optimizer import NetworkOptimizer
+from .network_config import NetworkConfig, _is_admin
+from .monitor import NetworkMonitor
+from .diagnostics import NetworkDiagnostics
+from .history import SessionHistory
+from pathlib import Path
+
+_optimizer = NetworkOptimizer()
+_config = NetworkConfig()
+_history = SessionHistory()  # Глобальная история для Collquan
+
+
+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_opt(args):
+    if args and args[0] == "start":
+        _optimizer.start()
+        print("Оптимизатор запущен.")
+    elif args and args[0] == "stop":
+        _optimizer.stop()
+        print("Оптимизатор остановлен.")
+    else:
+        print("Использование: ndopt start|stop")
+
+
+def _cmd_status(args):
+    s = _optimizer.status()
+    print(f"Запущен: {s['running']}")
+    print(f"DNS-кэш: {s['dns_cache_size']} записей (TTL {s['dns_ttl']}s)")
+
+
+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 "нет")
+
+
+def _cmd_live(args):
+    print("Запуск мониторинга в реальном времени (Ctrl+C для выхода)...")
+    monitor = NetworkMonitor(history=_history)
+    monitor.run()
+
+
+def _cmd_diag(args):
+    print("Запуск диагностики сети...\n")
+    diag = NetworkDiagnostics()
+    print(diag.get_report())
+
+
+def _cmd_export(args):
+    if not _history.records:
+        print("История пуста.")
+        return
+    reports_dir = Path.home() / ".ndvpi" / "reports"
+    p_json = _history.export_json(reports_dir / "collquan_session.json")
+    p_csv = _history.export_csv(reports_dir / "collquan_session.csv")
+    print(f"Экспортировано:\n  {p_json}\n  {p_csv}")
+
+
+if CollquanShell is not None:
+    CollquanShell.register("ndscan", "Сканировать Wi-Fi")(_cmd_scan)
+    CollquanShell.register("ndinfo", "Информация о сети")(_cmd_info)
+    CollquanShell.register("ndopt", "Оптимизатор: start/stop")(_cmd_opt)
+    CollquanShell.register("ndstatus", "Статус оптимизатора")(_cmd_status)
+    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)
+    CollquanShell.register("ndlive", "Live-монитор сети")(_cmd_live)
+    CollquanShell.register("nddiag", "Диагностика сети")(_cmd_diag)
+    CollquanShell.register("ndexport", "Экспорт истории в JSON/CSV")(_cmd_export)

ndvpi/diagnostics.py

@@ -0,0 +1,126 @@
+"""Диагностика сети: выявление проблем и рекомендации."""
+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 = name
+        self.ok = ok
+        self.details = details
+        self.recommendation = recommendation
+
+    def __str__(self):
+        return f"{'[OK]' if self.ok else '[FAIL]'} {self.name}: {self.details}"
+
+
+class NetworkDiagnostics:
+    def __init__(self):
+        self.info = NetworkInfo()
+        self.wifi = WiFiScanner()
+        self.config = NetworkConfig()
+
+    def run_checks(self):
+        results = []
+
+        # 1. Адаптеры
+        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', 'Неизвестно')}"))
+
+        # 2. Wi-Fi
+        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, "Wi-Fi не активен (возможно Ethernet)"))
+
+        # 3. Шлюз
+        gw = self.info.gateway()
+        if not gw:
+            results.append(CheckResult("Шлюз", False,
+                                        "Шлюз не найден",
+                                        "Проверьте настройки DHCP или задайте IP вручную"))
+        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} не отвечает",
+                                            "Проблема с роутером или кабелем. Перезагрузите роутер."))
+
+        # 4. DNS
+        try:
+            socket.gethostbyname("google.com")
+            results.append(CheckResult("DNS", True, "Разрешение имён работает"))
+        except socket.gaierror:
+            results.append(CheckResult("DNS", False,
+                                        "Не удаётся разрешить домены",
+                                        "Смените DNS на 1.1.1.1 (Cloudflare) или 8.8.8.8 (Google)"))
+
+        # 5. Пинг/Интернет
+        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}%",
+                                            "Возможны помехи Wi-Fi или перегрузка канала."))
+            elif ping_stats["avg"] > 150:
+                results.append(CheckResult("Пинг", False,
+                                            f"Высокий пинг: {ping_stats['avg']:.0f} ms",
+                                            "Попробуйте запустить оптимизатор (TCP_NODELAY) или сменить DNS."))
+            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 = []
+            for r in results:
+                status = "✔ OK" if r.ok else "✖ ОШИБКА"
+                rows.append([status, r.name, r.details or "", r.recommendation or ""])
+
+            out = [ui.table(["Статус", "Проверка", "Детали", "Рекомендация"], rows)]
+            out.append("")
+            if fails:
+                out.append(ui.render_warning(
+                    "Обнаружены проблемы. Ознакомьтесь с рекомендациями выше."))
+            else:
+                out.append(ui.render_success("Сеть работает стабильно."))
+            return "\n".join(out)
+
+        # Plain-режим
+        out = ["=== Диагностика сети ==="]
+        for r in results:
+            status = "[+]" if r.ok else "[x]"
+            out.append(f"{status} {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,92 @@
+"""История метрик сети за сессию и экспорт в JSON/CSV."""
+import json
+import csv
+import time
+from pathlib import Path
+
+class SessionHistory:
+    """Сборщик истории пингов и скоростей."""
+
+    def __init__(self):
+        self.records = []  # Список dict: {"ts": float, "type": str, "data": dict}
+
+    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:
+            avg_ping = sum(p["data"]["avg"] for p in pings) / len(pings)
+            avg_loss = sum(p["data"]["loss"] for p in pings) / len(pings)
+            avg_jitter = sum(p["data"]["jitter"] for p in pings) / len(pings)
+            result.update({
+                "avg_ping_ms": round(avg_ping, 2),
+                "avg_loss_pct": round(avg_loss, 2),
+                "avg_jitter_ms": round(avg_jitter, 2)
+            })
+        
+        if speeds:
+            avg_down = sum(s["data"]["download"] for s in speeds) / len(speeds)
+            avg_up = sum(s["data"]["upload"] for s in speeds) / len(speeds)
+            result.update({
+                "avg_download_mbps": round(avg_down, 2),
+                "avg_upload_mbps": round(avg_up, 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)