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

{nord_config_generator-1.0.4 → nord_config_generator-1.0.5}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: nord-config-generator
-Version: 1.0.4
+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: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Networking
 Classifier: Environment :: Console
@@ -15,3 +15,25 @@ 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.4 → 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.4"
-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.4 → nord_config_generator-1.0.5}/src/nord_config_generator.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: nord-config-generator
-Version: 1.0.4
+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: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Networking
 Classifier: Environment :: Console
@@ -15,3 +15,25 @@ 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.4 → nord_config_generator-1.0.5}/src/nord_config_generator.egg-info/SOURCES.txt

@@ -1,6 +1,10 @@
+README.md
 pyproject.toml
 src/nord_config_generator/__init__.py
+src/nord_config_generator/client.py
+src/nord_config_generator/generator.py
 src/nord_config_generator/main.py
+src/nord_config_generator/models.py
 src/nord_config_generator/ui.py
 src/nord_config_generator.egg-info/PKG-INFO
 src/nord_config_generator.egg-info/SOURCES.txt

nord_config_generator-1.0.4/src/nord_config_generator/main.py

@@ -1,384 +0,0 @@
-import sys
-import os
-import asyncio
-import json
-import base64
-import time
-from typing import List, Tuple, Optional, Dict, Any
-from dataclasses import dataclass
-from pathlib import Path
-from math import radians, sin, cos, asin, sqrt
-from functools import partial
-from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
-
-import aiohttp
-import aiofiles
-
-from .ui import ConsoleManager
-
-@dataclass
-class Server:
-    name: str
-    hostname: str
-    station: str
-    load: int
-    country: str
-    country_code: str
-    city: str
-    latitude: float
-    longitude: float
-    public_key: str
-    distance: float = 0.0
-
-@dataclass
-class UserPreferences:
-    dns: str = "103.86.96.100"
-    use_ip_for_endpoint: bool = False
-    persistent_keepalive: int = 25
-
-@dataclass
-class GenerationStats:
-    total_configs: int = 0
-    best_configs: int = 0
-
-class NordVpnApiClient:
-    NORD_API_BASE_URL = "https://api.nordvpn.com/v1"
-    LOCATION_API_URL = "https://ipinfo.io/json"
-
-    def __init__(self, console_manager: ConsoleManager):
-        self._console = console_manager
-        self._session: Optional[aiohttp.ClientSession] = None
-
-    async def __aenter__(self):
-        self._session = aiohttp.ClientSession()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self._session:
-            await self._session.close()
-
-    async def get_private_key(self, token: str) -> Optional[str]:
-        auth_header = base64.b64encode(f'token:{token}'.encode()).decode()
-        url = f"{self.NORD_API_BASE_URL}/users/services/credentials"
-        headers = {'Authorization': f'Basic {auth_header}'}
-        data = await self._get(url, headers=headers)
-        if isinstance(data, dict):
-            return data.get('nordlynx_private_key')
-        return None
-
-    async def get_all_servers(self) -> List[Dict[str, Any]]:
-        url = f"{self.NORD_API_BASE_URL}/servers"
-        params = {'limit': 16384, 'filters[servers_technologies][identifier]': 'wireguard_udp'}
-        data = await self._get(url, params=params)
-        return data if isinstance(data, list) else []
-
-    async def get_user_geolocation(self) -> Optional[Tuple[float, float]]:
-        data = await self._get(self.LOCATION_API_URL)
-        if not isinstance(data, dict):
-            return None
-        try:
-            lat, lon = data.get('loc', '').split(',')
-            return float(lat), float(lon)
-        except (ValueError, IndexError):
-            self._console.print_message("error", "Could not parse location data.")
-            return None
-
-    async def _get(self, url: str, **kwargs) -> Optional[Any]:
-        if not self._session:
-            return None
-        try:
-            async with self._session.get(url, **kwargs) as response:
-                response.raise_for_status()
-                return await response.json()
-        except (aiohttp.ClientError, json.JSONDecodeError) as e:
-            self._console.print_message("error", f"API request failed for {url}: {e}")
-            return None
-
-class ConfigurationOrchestrator:
-    CONCURRENT_LIMIT = 200
-    _path_sanitizer = str.maketrans('', '', '<>:"/\\|?*\0')
-
-    def __init__(self, private_key: str, preferences: UserPreferences, console_manager: ConsoleManager, api_client: NordVpnApiClient):
-        self._private_key = private_key
-        self._preferences = preferences
-        self._console = console_manager
-        self._api_client = api_client
-        self._output_dir = Path(f'nordvpn_configs_{datetime.now().strftime("%Y%m%d_%H%M%S")}')
-        self._semaphore = asyncio.Semaphore(self.CONCURRENT_LIMIT)
-        self.stats = GenerationStats()
-
-    async def generate(self) -> Optional[Path]:
-        user_location, all_servers_data = await self._fetch_remote_data()
-        if not user_location or not all_servers_data:
-            return None
-
-        processed_servers = await self._process_server_data(all_servers_data, user_location)
-        
-        unique_servers = {}
-        for s in processed_servers:
-            if s.name not in unique_servers:
-                unique_servers[s.name] = s
-        processed_servers = list(unique_servers.values())
-        
-        sorted_servers = sorted(processed_servers, key=lambda s: (s.load, s.distance))
-        best_servers_by_location = self._get_best_servers(sorted_servers)
-        
-        self._output_dir.mkdir(exist_ok=True)
-        servers_info = self._build_servers_info(sorted_servers)
-        
-        await self._save_all_configurations(sorted_servers, best_servers_by_location, servers_info)
-        return self._output_dir
-
-    async def _fetch_remote_data(self) -> Tuple[Optional[Tuple[float, float]], List[Dict[str, Any]]]:
-        with self._console.create_progress_bar() as progress:
-            task = progress.add_task("Fetching remote data...", total=2)
-            user_location, all_servers_data = await asyncio.gather(
-                self._api_client.get_user_geolocation(),
-                self._api_client.get_all_servers()
-            )
-            progress.update(task, advance=2)
-        return user_location, all_servers_data
-
-    async def _process_server_data(self, all_servers_data: List[Dict[str, Any]], user_location: Tuple[float, float]) -> List[Server]:
-        loop = asyncio.get_running_loop()
-        parse_func = partial(self._parse_server_data, user_location=user_location)
-        with ThreadPoolExecutor(max_workers=min(32, (os.cpu_count() or 1) + 4)) as executor:
-            tasks = [loop.run_in_executor(executor, parse_func, s) for s in all_servers_data]
-            processed_servers = await asyncio.gather(*tasks)
-        return [server for server in processed_servers if server]
-
-    def _get_best_servers(self, sorted_servers: List[Server]) -> Dict[Tuple[str, str], Server]:
-        best = {}
-        for server in sorted_servers:
-            key = (server.country, server.city)
-            if key not in best or server.load < best[key].load:
-                best[key] = server
-        return best
-
-    def _build_servers_info(self, sorted_servers: List[Server]) -> Dict:
-        info = {}
-        for server in sorted_servers:
-            country_info = info.setdefault(server.country, {})
-            city_info = country_info.setdefault(server.city, {"distance": int(server.distance), "servers": []})
-            city_info["servers"].append((server.name, server.load))
-        return info
-
-    async def _save_all_configurations(self, sorted_servers: List[Server], best_servers: Dict, servers_info: Dict):
-        used_paths: Dict[str, int] = {}
-        
-        with self._console.create_progress_bar(transient=False) as progress:
-            self.stats.total_configs = len(sorted_servers)
-            self.stats.best_configs = len(best_servers)
-
-            task_all = progress.add_task("Generating standard configs...", total=self.stats.total_configs)
-            task_best = progress.add_task("Generating optimized configs...", total=self.stats.best_configs)
-            
-            save_tasks = []
-            save_tasks.extend(self._create_batch_save_tasks(sorted_servers, 'configs', progress, task_all, used_paths))
-            save_tasks.extend(self._create_batch_save_tasks(list(best_servers.values()), 'best_configs', progress, task_best, used_paths))
-            
-            await asyncio.gather(*save_tasks)
-            async with aiofiles.open(self._output_dir / 'servers.json', 'w') as f:
-                await f.write(json.dumps(servers_info, indent=2, separators=(',', ':'), ensure_ascii=False))
-
-    def _create_batch_save_tasks(self, servers: List[Server], subfolder: str, progress, task_id, used_paths: Dict[str, int]):
-        tasks = []
-        for server in servers:
-            country_clean = self._sanitize_path_part(server.country)
-            city_clean = self._sanitize_path_part(server.city)
-            dir_path = self._output_dir / subfolder / country_clean / city_clean
-            
-            base_filename = self._extract_base_filename(server)
-            rel_path = f"{subfolder}/{country_clean}/{city_clean}/{base_filename}"
-            
-            if rel_path in used_paths:
-                idx = used_paths[rel_path]
-                if idx == 0: idx = 1
-                
-                base_path_no_ext = rel_path[:-5]
-                base_name_no_ext = base_filename[:-5]
-                
-                while True:
-                    new_rel = f"{base_path_no_ext}_{idx}.conf"
-                    if new_rel not in used_paths:
-                        used_paths[rel_path] = idx + 1
-                        used_paths[new_rel] = 0
-                        filename = f"{base_name_no_ext}_{idx}.conf"
-                        break
-                    idx += 1
-            else:
-                filename = base_filename
-                used_paths[rel_path] = 0
-
-            config_str = self._generate_wireguard_config_string(server, self._preferences, self._private_key)
-            tasks.append(self._save_config_file(config_str, dir_path, filename, progress, task_id))
-        return tasks
-
-    async def _save_config_file(self, config_string: str, path: Path, filename: str, progress, task_id):
-        path.mkdir(parents=True, exist_ok=True)
-        async with self._semaphore:
-            async with aiofiles.open(path / filename, 'w') as f:
-                await f.write(config_string)
-        progress.update(task_id, advance=1)
-
-    @staticmethod
-    def _extract_base_filename(server: Server) -> str:
-        s = server.name
-        num = ""
-        for i in range(len(s) - 1, -1, -1):
-            if s[i].isdigit():
-                start = i
-                while start >= 0 and s[start].isdigit():
-                    start -= 1
-                num = s[start+1 : i+1]
-                break
-        
-        if not num:
-            fallback = f"wg{server.station.replace('.', '')}"
-            return f"{fallback[:15]}.conf"
-        
-        base = f"{server.country_code}{num}"
-        return f"{base[:15]}.conf"
-
-    @staticmethod
-    def _generate_wireguard_config_string(server: Server, preferences: UserPreferences, private_key: str) -> str:
-        endpoint = server.station if preferences.use_ip_for_endpoint else server.hostname
-        return f"[Interface]\nPrivateKey = {private_key}\nAddress = 10.5.0.2/16\nDNS = {preferences.dns}\n\n[Peer]\nPublicKey = {server.public_key}\nAllowedIPs = 0.0.0.0/0, ::/0\nEndpoint = {endpoint}:51820\nPersistentKeepalive = {preferences.persistent_keepalive}"
-
-    @staticmethod
-    def _parse_server_data(server_data: Dict[str, Any], user_location: Tuple[float, float]) -> Optional[Server]:
-        try:
-            location = server_data['locations'][0]
-            country_info = location['country']
-            
-            public_key = next(
-                m['value'] for t in server_data['technologies']
-                if t['identifier'] == 'wireguard_udp'
-                for m in t['metadata'] if m['name'] == 'public_key'
-            )
-            distance = ConfigurationOrchestrator._calculate_distance(
-                user_location[0], user_location[1], location['latitude'], location['longitude']
-            )
-            return Server(
-                name=server_data['name'], hostname=server_data['hostname'],
-                station=server_data['station'], load=int(server_data.get('load', 0)),
-                country=country_info['name'], country_code=country_info['code'].lower(),
-                city=country_info.get('city', {}).get('name', 'Unknown'),
-                latitude=location['latitude'], longitude=location['longitude'],
-                public_key=public_key, distance=distance
-            )
-        except (KeyError, IndexError, StopIteration):
-            return None
-
-    @staticmethod
-    def _calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
-        lon1_rad, lat1_rad, lon2_rad, lat2_rad = map(radians, [lon1, lat1, lon2, lat2])
-        dlon = lon2_rad - lon1_rad
-        dlat = lat2_rad - lat1_rad
-        a = sin(dlat / 2)**2 + cos(lat1_rad) * cos(lat2_rad) * sin(dlon / 2)**2
-        c = 2 * asin(sqrt(a))
-        return c * 6371
-
-    @classmethod
-    def _sanitize_path_part(cls, part: str) -> str:
-        return part.lower().replace(' ', '_').replace('#', '').translate(cls._path_sanitizer)
-
-class Application:
-    def __init__(self):
-        self._console = ConsoleManager()
-
-    async def run(self, args: List[str]):
-        async with NordVpnApiClient(self._console) as api_client:
-            try:
-                if not args:
-                    await self._run_generate_command(api_client)
-                elif args[0] == "get-key" and len(args) == 1:
-                    await self._run_get_key_command(api_client)
-                else:
-                    command = " ".join(args)
-                    self._console.print_message("error", f"Unknown command or invalid arguments: '{command}'.")
-                    self._console.print_message("info", "Usage: nordgen | nordgen get-key")
-            except Exception as e:
-                self._console.print_message("error", f"An unrecoverable error occurred: {e}")
-
-    async def _run_get_key_command(self, api_client: NordVpnApiClient):
-        self._console.clear()
-        self._console.print_title()
-        private_key = await self._get_validated_private_key(api_client)
-        if private_key:
-            self._console.display_key(private_key)
-
-    async def _run_generate_command(self, api_client: NordVpnApiClient):
-        self._console.clear()
-        self._console.print_title()
-        private_key = await self._get_validated_private_key(api_client)
-        if not private_key:
-            return
-
-        preferences = self._collect_user_preferences()
-        
-        self._console.clear()
-        
-        start_time = time.time()
-        orchestrator = ConfigurationOrchestrator(private_key, preferences, self._console, api_client)
-        output_dir = await orchestrator.generate()
-        elapsed_time = time.time() - start_time
-        
-        if output_dir:
-            self._console.display_summary(output_dir, orchestrator.stats, elapsed_time)
-        else:
-            self._console.print_message("error", "Process failed. Check logs for details.")
-
-    def _collect_user_preferences(self) -> UserPreferences:
-        defaults = UserPreferences()
-        user_input = self._console.get_preferences(defaults)
-
-        dns_input = user_input.get("dns")
-        if dns_input:
-            parts = dns_input.split('.')
-            if len(parts) == 4 and all(p.isdigit() and 0 <= int(p) <= 255 for p in parts):
-                defaults.dns = dns_input
-        
-        use_ip = user_input.get("endpoint_type", "").lower() == 'y'
-
-        keepalive_input = user_input.get("keepalive")
-        if keepalive_input and keepalive_input.isdigit():
-            keepalive_val = int(keepalive_input)
-            if 15 <= keepalive_val <= 120:
-                defaults.persistent_keepalive = keepalive_val
-        
-        return UserPreferences(
-            dns=defaults.dns,
-            use_ip_for_endpoint=use_ip,
-            persistent_keepalive=defaults.persistent_keepalive
-        )
-
-    async def _get_validated_private_key(self, api_client: NordVpnApiClient) -> Optional[str]:
-        token = self._console.get_user_input("Please enter your NordVPN access token: ", is_secret=True)
-        is_hex = len(token) == 64 and all(c in '0123456789abcdefABCDEF' for c in token)
-        if not is_hex:
-            self._console.print_message("error", "Invalid token format.")
-            return None
-        
-        with self._console.create_progress_bar() as progress:
-            task = progress.add_task("Validating token...", total=1)
-            private_key = await api_client.get_private_key(token)
-            progress.update(task, advance=1)
-        
-        if private_key:
-            self._console.print_message("success", "Token validated successfully.")
-            return private_key
-        else:
-            self._console.print_message("error", "Token is invalid or could not be verified.")
-            return None
-
-def cli_entry_point():
-    try:
-        app = Application()
-        asyncio.run(app.run(sys.argv[1:]))
-    except KeyboardInterrupt:
-        print("\nProcess interrupted by user.")
-
-if __name__ == "__main__":
-    cli_entry_point()

nord_config_generator-1.0.4/src/nord_config_generator/ui.py

@@ -1,73 +0,0 @@
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeElapsedColumn
-from rich.theme import Theme
-from rich.table import Table
-from pathlib import Path
-from typing import TYPE_CHECKING
-import os
-
-if TYPE_CHECKING:
-    from .main import UserPreferences, GenerationStats
-
-class ConsoleManager:
-    def __init__(self):
-        custom_theme = Theme({
-            "info": "cyan",
-            "success": "bold green",
-            "warning": "yellow",
-            "error": "bold red",
-            "title": "bold magenta",
-            "path": "underline bright_blue"
-        })
-        self.console = Console(theme=custom_theme)
-
-    def clear(self):
-        os.system('cls' if os.name == 'nt' else 'clear')
-
-    def print_title(self):
-        self.console.print(Panel("[title]NordVPN Configuration Generator[/title]", expand=False, border_style="info"))
-
-    def get_user_input(self, prompt: str, is_secret: bool = False) -> str:
-        return self.console.input(f"[info]{prompt}[/info]", password=is_secret).strip()
-
-    def get_preferences(self, defaults: "UserPreferences") -> dict:
-        self.console.print("\n[info]Configuration Options (press Enter to use defaults)[/info]")
-        dns = self.get_user_input(f"Enter DNS server IP (default: {defaults.dns}): ")
-        endpoint_type = self.get_user_input("Use IP instead of hostname for endpoints? (y/N): ")
-        keepalive = self.get_user_input(f"Enter PersistentKeepalive value (default: {defaults.persistent_keepalive}): ")
-        return {"dns": dns, "endpoint_type": endpoint_type, "keepalive": keepalive}
-
-    def print_message(self, style: str, message: str):
-        self.console.print(f"[{style}]{message}[/{style}]")
-
-    def create_progress_bar(self, transient: bool = True) -> Progress:
-        return Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            TimeElapsedColumn(),
-            console=self.console,
-            transient=transient
-        )
-
-    def display_key(self, key: str):
-        key_panel = Panel(key, title="NordLynx Private Key", border_style="success", expand=False)
-        self.console.print(key_panel)
-
-    def display_summary(self, output_dir: Path, stats: "GenerationStats", elapsed_time: float):
-        summary_table = Table.grid(padding=(0, 2))
-        summary_table.add_column(style="info")
-        summary_table.add_column()
-        summary_table.add_row("Output Directory:", f"[path]{output_dir}[/path]")
-        summary_table.add_row("Standard Configs:", f"{stats.total_configs}")
-        summary_table.add_row("Optimized Configs:", f"{stats.best_configs}")
-        summary_table.add_row("Time Taken:", f"{elapsed_time:.2f} seconds")
-
-        self.console.print(Panel(
-            summary_table,
-            title="[success]Generation Complete[/success]",
-            border_style="success",
-            expand=False
-        ))