nord-config-generator 1.0.3__tar.gz → 1.0.5__tar.gz

nord_config_generator-1.0.5/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: nord-config-generator
+Version: 1.0.5
+Summary: A command-line tool for generating optimized NordVPN WireGuard configurations.
+Author-email: Ahmed Touhami <mustafachyi272@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator
+Project-URL: Bug Tracker, https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Networking
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp<4.0,>=3.12.14
+Requires-Dist: aiofiles<25.0,>=24.1.0
+Requires-Dist: rich<15.0,>=14.0.0
+
+# NordVPN WireGuard Config Generator
+
+A command-line tool for generating optimized NordVPN WireGuard configurations.
+
+## Installation
+
+```bash
+pip install nord-config-generator
+```
+
+## Usage
+
+Generate configurations:
+```bash
+nordgen
+```
+
+Retrieve Private Key:
+```bash
+nordgen get-key
+```

nord_config_generator-1.0.5/README.md

@@ -0,0 +1,21 @@
+# NordVPN WireGuard Config Generator
+
+A command-line tool for generating optimized NordVPN WireGuard configurations.
+
+## Installation
+
+```bash
+pip install nord-config-generator
+```
+
+## Usage
+
+Generate configurations:
+```bash
+nordgen
+```
+
+Retrieve Private Key:
+```bash
+nordgen get-key
+```

{nord_config_generator-1.0.3 → nord_config_generator-1.0.5}/pyproject.toml

@@ -1,33 +1,32 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "nord-config-generator"
-version = "1.0.3"
-authors = [
-  { name="Ahmed Touhami", email="mustafachyi272@gmail.com" },
-]
-description = "A command-line tool for generating optimized NordVPN WireGuard configurations."
-readme = "README.md"
-license = { file="LICENSE" }
-requires-python = ">=3.9"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
-    "Operating System :: OS Independent",
-    "Topic :: System :: Networking",
-    "Environment :: Console",
-]
-dependencies = [
-    "aiohttp>=3.12.14, <4.0",
-    "aiofiles>=24.1.0, <25.0",
-    "rich>=14.0.0, <15.0",
-]
-
-[project.urls]
-"Homepage" = "https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator"
-"Bug Tracker" = "https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator/issues"
-
-[project.scripts]
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nord-config-generator"
+version = "1.0.5"
+authors = [
+  { name="Ahmed Touhami", email="mustafachyi272@gmail.com" },
+]
+description = "A command-line tool for generating optimized NordVPN WireGuard configurations."
+readme = "README.md"
+license = "GPL-3.0-or-later"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: System :: Networking",
+    "Environment :: Console",
+]
+dependencies = [
+    "aiohttp>=3.12.14, <4.0",
+    "aiofiles>=24.1.0, <25.0",
+    "rich>=14.0.0, <15.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator"
+"Bug Tracker" = "https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator/issues"
+
+[project.scripts]
 nordgen = "nord_config_generator.main:cli_entry_point"

nord_config_generator-1.0.5/src/nord_config_generator/client.py

@@ -0,0 +1,53 @@
+import aiohttp
+import json
+import base64
+from typing import Optional, List, Dict, Tuple
+
+class NordClient:
+    BASE_URL = "https://api.nordvpn.com/v1"
+    GEO_URL = "https://api.nordvpn.com/v1/helpers/ips/insights"
+
+    def __init__(self):
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def __aenter__(self):
+        timeout = aiohttp.ClientTimeout(total=20)
+        connector = aiohttp.TCPConnector(limit=10, ttl_dns_cache=300)
+        self._session = aiohttp.ClientSession(timeout=timeout, connector=connector)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._session:
+            await self._session.close()
+
+    async def get_key(self, token: str) -> Optional[str]:
+        if not self._session: return None
+        try:
+            auth = base64.b64encode(f'token:{token}'.encode()).decode()
+            headers = {'Authorization': f'Basic {auth}'}
+            async with self._session.get(f"{self.BASE_URL}/users/services/credentials", headers=headers) as resp:
+                if resp.status != 200: return None
+                data = await resp.json()
+                return data.get('nordlynx_private_key')
+        except (aiohttp.ClientError, json.JSONDecodeError):
+            return None
+
+    async def get_servers(self) -> List[Dict]:
+        if not self._session: return []
+        try:
+            params = {'limit': '16384', 'filters[servers_technologies][identifier]': 'wireguard_udp'}
+            async with self._session.get(f"{self.BASE_URL}/servers", params=params) as resp:
+                if resp.status != 200: return []
+                return await resp.json()
+        except (aiohttp.ClientError, json.JSONDecodeError):
+            return []
+
+    async def get_geo(self) -> Tuple[float, float]:
+        if not self._session: return 0.0, 0.0
+        try:
+            async with self._session.get(self.GEO_URL) as resp:
+                if resp.status != 200: return 0.0, 0.0
+                data = await resp.json()
+                return float(data.get('latitude', 0)), float(data.get('longitude', 0))
+        except (aiohttp.ClientError, json.JSONDecodeError, ValueError):
+            return 0.0, 0.0

nord_config_generator-1.0.5/src/nord_config_generator/generator.py

@@ -0,0 +1,212 @@
+import asyncio
+import os
+import aiofiles
+from typing import List, Dict, Optional, Set
+from math import radians, sin, cos, asin, sqrt
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from pathlib import Path
+from rich.progress import TaskID
+
+from .client import NordClient
+from .ui import ConsoleManager
+from .models import Server, UserPreferences, Stats
+
+class Generator:
+    MIN_VER_MAJOR = 2
+    MIN_VER_MINOR = 1
+
+    def __init__(self, client: NordClient, ui: ConsoleManager):
+        self.client = client
+        self.ui = ui
+        self.stats = Stats()
+        self.dir_cache: Set[str] = set()
+        self.out_dir = Path(f'nordvpn_configs_{datetime.now().strftime("%Y%m%d_%H%M%S")}')
+        self.path_sanitizer = str.maketrans('', '', '<>:"/\\|?*\0')
+
+    async def process(self, key: str, prefs: UserPreferences):
+        self.ui.spin("Fetching data...")
+        
+        geo_task = asyncio.create_task(self.client.get_geo())
+        srv_task = asyncio.create_task(self.client.get_servers())
+        
+        lat, lon = await geo_task
+        raw_servers = await srv_task
+        
+        if not raw_servers:
+            self.ui.fail("Failed to fetch server data")
+            return
+
+        self.ui.success("Data fetched")
+        self.ui.spin("Processing dataset...")
+
+        loop = asyncio.get_running_loop()
+        with ThreadPoolExecutor(max_workers=os.cpu_count() or 4) as pool:
+            processed = await loop.run_in_executor(pool, self._parse_batch, raw_servers, lat, lon)
+
+        unique = {s.name: s for s in processed}
+        final_list = list(unique.values())
+        final_list.sort(key=lambda x: (x.load, x.distance))
+        
+        self.stats.rejected = len(raw_servers) - len(final_list)
+        self.stats.total = len(final_list)
+        
+        best_map = {}
+        for s in final_list:
+            k = (s.country, s.city)
+            if k not in best_map or s.load < best_map[k].load:
+                best_map[k] = s
+        
+        self.stats.best = len(best_map)
+        best_list = list(best_map.values())
+
+        self.out_dir.mkdir(exist_ok=True)
+        self.dir_cache.add(str(self.out_dir))
+
+        self.ui.start_progress()
+        t1 = self.ui.add_task("Standard Configs", self.stats.total)
+        t2 = self.ui.add_task("Optimized Configs", self.stats.best)
+
+        await asyncio.gather(
+            self._write_batch(final_list, "configs", t1, key, prefs),
+            self._write_batch(best_list, "best_configs", t2, key, prefs)
+        )
+        self.ui.stop_progress()
+
+        return str(self.out_dir)
+
+    def _parse_batch(self, raw: List[Dict], lat: float, lon: float) -> List[Server]:
+        results = []
+        for d in raw:
+            s = self._parse_one(d, lat, lon)
+            if s:
+                results.append(s)
+        return results
+
+    def _parse_one(self, data: Dict, lat: float, lon: float) -> Optional[Server]:
+        try:
+            locs = data.get('locations')
+            if not locs: return None
+            
+            ver_str = "0.0.0"
+            for s in data.get('specifications', []):
+                if s.get('identifier') == 'version':
+                    vals = s.get('values')
+                    if vals: ver_str = vals[0].get('value', "0.0.0")
+                    break
+            
+            if not self._check_version(ver_str):
+                return None
+
+            pk = ""
+            for t in data.get('technologies', []):
+                if t.get('identifier') == 'wireguard_udp':
+                    for m in t.get('metadata', []):
+                        if m.get('name') == 'public_key':
+                            pk = m.get('value')
+                            break
+            if not pk: return None
+
+            loc = locs[0]
+            d = self._haversine(lat, lon, loc['latitude'], loc['longitude'])
+            
+            return Server(
+                name=data['name'],
+                hostname=data['hostname'],
+                station=data['station'],
+                load=int(data.get('load', 0)),
+                country=loc['country']['name'],
+                country_code=loc['country']['code'].lower(),
+                city=loc['country']['city']['name'],
+                latitude=loc['latitude'],
+                longitude=loc['longitude'],
+                public_key=pk,
+                distance=d
+            )
+        except (KeyError, IndexError, ValueError, TypeError):
+            return None
+
+    def _check_version(self, v: str) -> bool:
+        if len(v) < 3: return False
+        try:
+            parts = v.split('.')
+            if len(parts) < 2: return False
+            maj = int(parts[0])
+            if maj > 2: return True
+            return maj == 2 and int(parts[1]) >= 1
+        except ValueError:
+            return False
+
+    def _haversine(self, lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+        R = 6371
+        dlat = radians(lat2 - lat1)
+        dlon = radians(lon2 - lon1)
+        a = sin(dlat/2)**2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon/2)**2
+        c = 2 * asin(sqrt(a))
+        return R * c
+
+    async def _write_batch(self, servers: List[Server], sub: str, task_id: TaskID, key: str, prefs: UserPreferences):
+        sem = asyncio.Semaphore(200)
+        path_counts: Dict[str, int] = {}
+        
+        async def _write(s: Server):
+            async with sem:
+                country = self._sanitize(s.country)
+                city = self._sanitize(s.city)
+                base = self._basename(s)
+                rel = f"{sub}/{country}/{city}/{base}"
+                
+                count = path_counts.get(rel, 0)
+                path_counts[rel] = count + 1
+                
+                fname = base
+                if count > 0:
+                    raw_base = base[:-5]
+                    fname = f"{raw_base}_{count}.conf"
+
+                full_dir = self.out_dir / sub / country / city
+                self._ensure_dir(full_dir)
+                
+                ep = s.station if prefs.use_ip else s.hostname
+                cfg = (
+                    f"[Interface]\nPrivateKey = {key}\nAddress = 10.5.0.2/16\nDNS = {prefs.dns}\n\n"
+                    f"[Peer]\nPublicKey = {s.public_key}\nAllowedIPs = 0.0.0.0/0, ::/0\n"
+                    f"Endpoint = {ep}:51820\nPersistentKeepalive = {prefs.keepalive}"
+                )
+                
+                async with aiofiles.open(full_dir / fname, 'w') as f:
+                    await f.write(cfg)
+                self.ui.update_progress(task_id)
+
+        tasks = [_write(s) for s in servers]
+        await asyncio.gather(*tasks)
+
+    def _ensure_dir(self, path: Path):
+        s_path = str(path)
+        if s_path in self.dir_cache: return
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+            self.dir_cache.add(s_path)
+        except OSError:
+            pass
+
+    def _sanitize(self, s: str) -> str:
+        return s.lower().replace(' ', '_').translate(self.path_sanitizer)
+
+    def _basename(self, s: Server) -> str:
+        name = s.name
+        num = ""
+        for i in range(len(name)-1, -1, -1):
+            if name[i].isdigit():
+                start = i
+                while start >= 0 and name[start].isdigit():
+                    start -= 1
+                num = name[start+1:i+1]
+                break
+        
+        if not num:
+            fallback = f"wg{s.station.replace('.', '')}"
+            return f"{fallback[:15]}.conf"
+        
+        base = f"{s.country_code}{num}"
+        return f"{base[:15]}.conf"

nord_config_generator-1.0.5/src/nord_config_generator/main.py

@@ -0,0 +1,101 @@
+import sys
+import asyncio
+import argparse
+import time
+
+from .ui import ConsoleManager
+from .client import NordClient
+from .generator import Generator
+from .models import UserPreferences
+
+async def main():
+    ui = ConsoleManager()
+    async with NordClient() as client:
+        if len(sys.argv) > 1 and sys.argv[1] == "get-key":
+            await run_get_key(ui, client)
+        else:
+            await run_generate(ui, client)
+
+async def run_get_key(ui: ConsoleManager, client: NordClient):
+    parser = argparse.ArgumentParser(prog="nordgen get-key", description="Retrieve Private Key")
+    parser.add_argument('-t', '--token', help='NordVPN Access Token')
+    
+    args = parser.parse_args(sys.argv[2:])
+
+    ui.clear()
+    ui.header()
+    
+    key = await resolve_key(ui, client, args.token)
+    if key:
+        ui.show_key(key)
+    ui.wait()
+
+async def run_generate(ui: ConsoleManager, client: NordClient):
+    parser = argparse.ArgumentParser(prog="nordgen", description="NordVPN WireGuard Config Generator")
+    parser.add_argument('-t', '--token', help='NordVPN Access Token')
+    parser.add_argument('-d', '--dns', default='103.86.96.100', help='DNS Server')
+    parser.add_argument('-i', '--ip', action='store_true', help='Use IP Endpoint')
+    parser.add_argument('-k', '--keepalive', type=int, default=25, help='Persistent Keepalive')
+
+    args = parser.parse_args(sys.argv[1:])
+
+    ui.clear()
+    ui.header()
+    
+    prefs = UserPreferences(args.dns, args.ip, args.keepalive)
+    key = ""
+    
+    if not args.token:
+        key = await resolve_key(ui, client, "")
+        if not key:
+            ui.wait()
+            return
+        
+        ui.clear()
+        ui.header()
+        prefs = ui.prompt_prefs(prefs)
+    else:
+        key = await resolve_key(ui, client, args.token)
+        if not key:
+            ui.wait()
+            return
+
+    ui.clear()
+    ui.header()
+    
+    gen = Generator(client, ui)
+    start = time.time()
+    out = await gen.process(key, prefs)
+    
+    if out:
+        ui.clear()
+        ui.header()
+        ui.summary(out, gen.stats, time.time() - start)
+    
+    ui.wait()
+
+async def resolve_key(ui: ConsoleManager, client: NordClient, token: str) -> str:
+    if not token:
+        token = ui.prompt_secret("Please enter your NordVPN access token: ")
+    
+    if len(token) != 64:
+        ui.error("Invalid token format")
+        return ""
+
+    ui.spin("Validating token...")
+    key = await client.get_key(token)
+    if not key:
+        ui.fail("Token invalid")
+        return ""
+    
+    ui.success("Token validated")
+    return key
+
+def cli_entry_point():
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass
+
+if __name__ == "__main__":
+    cli_entry_point()

nord_config_generator-1.0.5/src/nord_config_generator/models.py

@@ -0,0 +1,39 @@
+class Server:
+    __slots__ = (
+        'name', 'hostname', 'station', 'load', 'country', 
+        'country_code', 'city', 'latitude', 'longitude', 
+        'public_key', 'distance'
+    )
+
+    def __init__(
+        self, name: str, hostname: str, station: str, load: int,
+        country: str, country_code: str, city: str,
+        latitude: float, longitude: float, public_key: str, distance: float
+    ):
+        self.name = name
+        self.hostname = hostname
+        self.station = station
+        self.load = load
+        self.country = country
+        self.country_code = country_code
+        self.city = city
+        self.latitude = latitude
+        self.longitude = longitude
+        self.public_key = public_key
+        self.distance = distance
+
+class UserPreferences:
+    __slots__ = ('dns', 'use_ip', 'keepalive')
+
+    def __init__(self, dns: str = "103.86.96.100", use_ip: bool = False, keepalive: int = 25):
+        self.dns = dns
+        self.use_ip = use_ip
+        self.keepalive = keepalive
+
+class Stats:
+    __slots__ = ('total', 'best', 'rejected')
+
+    def __init__(self):
+        self.total = 0
+        self.best = 0
+        self.rejected = 0

nord_config_generator-1.0.5/src/nord_config_generator/ui.py

@@ -0,0 +1,118 @@
+import os
+from typing import TYPE_CHECKING
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TaskID
+from rich.theme import Theme
+from rich.table import Table
+
+if TYPE_CHECKING:
+    from .models import UserPreferences, Stats
+
+class ConsoleManager:
+    def __init__(self):
+        theme = Theme({
+            "info": "cyan",
+            "success": "bold green",
+            "warning": "yellow",
+            "error": "bold red",
+            "title": "bold magenta",
+        })
+        self.console = Console(theme=theme)
+        self.progress = None
+        self.task_ids = {}
+
+    def clear(self):
+        os.system('cls' if os.name == 'nt' else 'clear')
+
+    def header(self):
+        self.console.print(Panel(
+            "[title]NordVPN Configuration Generator[/title]", 
+            expand=False, 
+            border_style="cyan",
+            padding=(0, 2)
+        ))
+
+    def prompt_secret(self, msg: str) -> str:
+        return self.console.input(f"[cyan]{msg}[/cyan]", password=True).strip()
+
+    def prompt_prefs(self, defaults: "UserPreferences") -> "UserPreferences":
+        from .models import UserPreferences
+        self.console.print("[info]Configuration Options (Enter for default)[/info]")
+        
+        d_in = self.console.input(f"DNS IP (default: {defaults.dns}): ").strip()
+        dns = d_in if d_in else defaults.dns
+        
+        i_in = self.console.input("Use IP for endpoints? (y/N): ").strip().lower()
+        use_ip = i_in == 'y'
+        
+        k_in = self.console.input(f"PersistentKeepalive (default: {defaults.keepalive}): ").strip()
+        ka = int(k_in) if k_in.isdigit() else defaults.keepalive
+        
+        return UserPreferences(dns, use_ip, ka)
+
+    def spin(self, msg: str):
+        with self.console.status(f"[cyan]{msg}"):
+            pass
+
+    def success(self, msg: str):
+        self.console.print(f"[success]{msg}[/success]")
+
+    def fail(self, msg: str):
+        self.console.print(f"[error]{msg}[/error]")
+
+    def error(self, msg: str):
+        self.console.print(f"[error]{msg}[/error]")
+
+    def show_key(self, key: str):
+        self.console.print(Panel(
+            f"[green]{key}[/green]", 
+            title="NordLynx Private Key", 
+            border_style="green",
+            expand=False
+        ))
+
+    def summary(self, path: str, stats: "Stats", sec: float):
+        grid = Table.grid(padding=(0, 2))
+        grid.add_column(style="cyan")
+        grid.add_column()
+        grid.add_row("Output Directory:", path)
+        grid.add_row("Standard Configs:", str(stats.total))
+        grid.add_row("Optimized Configs:", str(stats.best))
+        grid.add_row("Incompatible:", f"[yellow]{stats.rejected}[/yellow]")
+        grid.add_row("Duration:", f"{sec:.2f}s")
+        
+        self.console.print(Panel(
+            grid, 
+            title="Complete", 
+            border_style="green", 
+            expand=False
+        ))
+
+    def start_progress(self):
+        self.progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("{task.completed}/{task.total}"),
+            console=self.console,
+            transient=False
+        )
+        self.progress.start()
+
+    def add_task(self, name: str, total: int) -> TaskID:
+        if self.progress:
+            return self.progress.add_task(name, total=total)
+        return TaskID(0)
+
+    def update_progress(self, task_id: TaskID):
+        if self.progress:
+            self.progress.update(task_id, advance=1)
+
+    def stop_progress(self):
+        if self.progress:
+            self.progress.stop()
+
+    def wait(self):
+        self.console.print()
+        self.console.input("[info]Press Enter to exit...[/info]")

nord_config_generator-1.0.5/src/nord_config_generator.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: nord-config-generator
+Version: 1.0.5
+Summary: A command-line tool for generating optimized NordVPN WireGuard configurations.
+Author-email: Ahmed Touhami <mustafachyi272@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator
+Project-URL: Bug Tracker, https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Networking
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp<4.0,>=3.12.14
+Requires-Dist: aiofiles<25.0,>=24.1.0
+Requires-Dist: rich<15.0,>=14.0.0
+
+# NordVPN WireGuard Config Generator
+
+A command-line tool for generating optimized NordVPN WireGuard configurations.
+
+## Installation
+
+```bash
+pip install nord-config-generator
+```
+
+## Usage
+
+Generate configurations:
+```bash
+nordgen
+```
+
+Retrieve Private Key:
+```bash
+nordgen get-key
+```