nord-config-generator 1.0.0__py3-none-any.whl

nord_config_generator/main.py

@@ -0,0 +1,282 @@
+import sys
+import os
+import asyncio
+import json
+import base64
+import re
+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
+
+NORD_API_BASE_URL = "https://api.nordvpn.com/v1"
+LOCATION_API_URL = "https://ipinfo.io/json"
+CONCURRENT_LIMIT = 200
+
+@dataclass
+class Server:
+    name: str
+    hostname: str
+    station: str
+    load: int
+    country: 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
+
+    def update_from_input(self, user_input: dict):
+        dns_input = user_input.get("dns")
+        if dns_input and re.match(r'^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$', dns_input):
+            self.dns = dns_input
+
+        self.use_ip_for_endpoint = user_input.get("endpoint_type", "").lower() == 'y'
+
+        keepalive_input = user_input.get("keepalive")
+        if keepalive_input and keepalive_input.isdigit() and 15 <= int(keepalive_input) <= 120:
+            self.persistent_keepalive = int(keepalive_input)
+
+class NordVpnApiClient:
+    def __init__(self, console_manager: ConsoleManager):
+        self._session = aiohttp.ClientSession()
+        self._console = console_manager
+
+    async def _get(self, url: str, **kwargs) -> Optional[Any]:
+        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
+
+    async def get_private_key(self, token: str) -> Optional[str]:
+        auth_header = base64.b64encode(f'token:{token}'.encode()).decode()
+        url = f"{NORD_API_BASE_URL}/users/services/credentials"
+        data = await self._get(url, headers={'Authorization': f'Basic {auth_header}'})
+        if isinstance(data, dict):
+            return data.get('nordlynx_private_key')
+        return None
+
+    async def get_all_servers(self) -> List[Dict[str, Any]]:
+        url = f"{NORD_API_BASE_URL}/servers"
+        params = {'limit': 9000, 'filters[servers_technologies][identifier]': 'wireguard_udp'}
+        data = await self._get(url, params=params)
+        if isinstance(data, list):
+            return data
+        return []
+
+    async def get_user_geolocation(self) -> Optional[Tuple[float, float]]:
+        data = await self._get(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 close(self):
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+class ConfigurationOrchestrator:
+    def __init__(self, private_key: str, preferences: UserPreferences, console_manager: ConsoleManager, api_client: NordVpnApiClient):
+        self._api_client = api_client
+        self._private_key = private_key
+        self._preferences = preferences
+        self._console = console_manager
+        self._output_dir = Path(f'nordvpn_configs_{datetime.now().strftime("%Y%m%d_%H%M%S")}')
+        self._semaphore = asyncio.Semaphore(CONCURRENT_LIMIT)
+        self._thread_pool = ThreadPoolExecutor(max_workers=min(32, (os.cpu_count() or 1) + 4))
+        self.generation_succeeded = False
+        self.stats = {"total": 0, "best": 0}
+
+    @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])
+        a = sin((lat2_rad - lat1_rad) / 2)**2 + cos(lat1_rad) * cos(lat2_rad) * sin((lon2_rad - lon1_rad) / 2)**2
+        return 2 * asin(sqrt(a)) * 6371
+
+    def _parse_server_data(self, server_data: Dict[str, Any], user_location: Tuple[float, float]) -> Optional[Server]:
+        try:
+            location = server_data['locations'][0]
+            public_key = next(
+                tech_meta['value']
+                for tech in server_data['technologies'] if tech['identifier'] == 'wireguard_udp'
+                for tech_meta in tech['metadata'] if tech_meta['name'] == 'public_key'
+            )
+            return Server(
+                name=server_data['name'], hostname=server_data['hostname'], station=server_data['station'],
+                load=int(server_data.get('load', 0)), country=location['country']['name'],
+                city=location['country'].get('city', {}).get('name', 'Unknown'), latitude=location['latitude'],
+                longitude=location['longitude'], public_key=public_key,
+                distance=self._calculate_distance(user_location[0], user_location[1], location['latitude'], location['longitude'])
+            )
+        except (KeyError, IndexError, StopIteration):
+            return None
+
+    def _generate_wireguard_config_string(self, server: Server) -> str:
+        endpoint = server.station if self._preferences.use_ip_for_endpoint else server.hostname
+        return f"[Interface]\nPrivateKey = {self._private_key}\nAddress = 10.5.0.2/16\nDNS = {self._preferences.dns}\n\n[Peer]\nPublicKey = {server.public_key}\nAllowedIPs = 0.0.0.0/0, ::/0\nEndpoint = {endpoint}:51820\nPersistentKeepalive = {self._preferences.persistent_keepalive}"
+
+    @staticmethod
+    def _sanitize_path_part(part: str) -> str:
+        return re.sub(r'[<>:"/\\|?*\0]', '', part.lower().replace(' ', '_')).replace('#', '')
+
+    async def _save_config_file(self, config_string: str, path: Path, filename: str, progress, task):
+        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, advance=1)
+
+    async def generate(self) -> Optional[Path]:
+        progress = self._console.create_progress_bar()
+        with progress:
+            task_data = progress.add_task("Fetching remote data...", total=2)
+            
+            progress.update(task_data, description="Fetching user location...")
+            user_location, all_servers_data = await asyncio.gather(
+                self._api_client.get_user_geolocation(),
+                self._api_client.get_all_servers()
+            )
+            
+            if not user_location or not all_servers_data:
+                return None
+            
+            progress.update(task_data, advance=2, description="Processing servers...")
+
+            loop = asyncio.get_running_loop()
+            parse_func = partial(self._parse_server_data, user_location=user_location)
+            parse_tasks = [loop.run_in_executor(self._thread_pool, parse_func, s) for s in all_servers_data]
+            
+            processed_servers = [server for server in await asyncio.gather(*parse_tasks) if server]
+            self._thread_pool.shutdown(wait=False, cancel_futures=True)
+
+        sorted_servers = sorted(processed_servers, key=lambda s: (s.load, s.distance))
+        
+        self._output_dir.mkdir(exist_ok=True)
+        servers_info, best_servers_by_location = {}, {}
+        
+        config_progress = self._console.create_progress_bar(transient=False)
+        with config_progress:
+            total_configs = len(sorted_servers)
+            best_configs = 0
+            
+            save_tasks = []
+            task_save_all = config_progress.add_task("Generating configs...", total=total_configs)
+            for server in sorted_servers:
+                country_sanitized = self._sanitize_path_part(server.country)
+                city_sanitized = self._sanitize_path_part(server.city)
+                config_str = self._generate_wireguard_config_string(server)
+                path = self._output_dir / 'configs' / country_sanitized / city_sanitized
+                filename = f"{self._sanitize_path_part(server.name)}.conf"
+                save_tasks.append(self._save_config_file(config_str, path, filename, config_progress, task_save_all))
+                
+                location_key = (server.country, server.city)
+                if location_key not in best_servers_by_location or server.load < best_servers_by_location[location_key].load:
+                    best_servers_by_location[location_key] = server
+                
+                country_info = servers_info.setdefault(server.country, {})
+                city_info = country_info.setdefault(server.city, {"distance": int(server.distance), "servers": []})
+                city_info["servers"].append((server.name, server.load))
+
+            self.stats["total"] = total_configs
+            await asyncio.gather(*save_tasks)
+
+            best_save_tasks = []
+            best_configs = len(best_servers_by_location)
+            task_save_best = config_progress.add_task("Generating optimized configs...", total=best_configs)
+            for server in best_servers_by_location.values():
+                country_sanitized = self._sanitize_path_part(server.country)
+                city_sanitized = self._sanitize_path_part(server.city)
+                config_str = self._generate_wireguard_config_string(server)
+                path = self._output_dir / 'best_configs' / country_sanitized / city_sanitized
+                filename = f"{self._sanitize_path_part(server.name)}.conf"
+                best_save_tasks.append(self._save_config_file(config_str, path, filename, config_progress, task_save_best))
+            
+            self.stats["best"] = best_configs
+            await asyncio.gather(*best_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))
+        
+        self.generation_succeeded = True
+        return self._output_dir
+
+def is_valid_token_format(token: str) -> bool:
+    return bool(re.match(r'^[a-fA-F0-9]{64}$', token))
+
+async def main_async():
+    console = ConsoleManager()
+    api_client = NordVpnApiClient(console)
+
+    try:
+        console.clear()
+        console.print_title()
+
+        token = console.get_user_input("Please enter your NordVPN access token: ", is_secret=True)
+        if not is_valid_token_format(token):
+            console.print_message("error", "Invalid token format.")
+            return
+
+        private_key = None
+        with 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 not private_key:
+            console.print_message("error", "Token is invalid or could not be verified. Please check the token and try again.")
+            return
+
+        console.print_message("success", "Token validated successfully.")
+        
+        preferences = UserPreferences()
+        user_input = console.get_preferences(preferences)
+        preferences.update_from_input(user_input)
+        
+        console.clear()
+        
+        start_time = time.time()
+        orchestrator = ConfigurationOrchestrator(private_key, preferences, console, api_client)
+        
+        output_directory = await orchestrator.generate()
+        elapsed_time = time.time() - start_time
+        
+        if orchestrator.generation_succeeded and output_directory:
+            console.print_summary(output_directory, orchestrator.stats["total"], orchestrator.stats["best"], elapsed_time)
+        else:
+            console.print_message("error", "Process failed. Check the logs for details.")
+            
+    except Exception as e:
+        console.print_message("error", f"An unrecoverable error occurred: {e}")
+    finally:
+        await api_client.close()
+
+def cli_entry_point():
+    try:
+        asyncio.run(main_async())
+    except KeyboardInterrupt:
+        print("\nProcess interrupted by user.")
+
+if __name__ == "__main__":
+    cli_entry_point()

nord_config_generator/ui.py

@@ -0,0 +1,65 @@
+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
+import os
+
+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) -> 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 print_summary(self, output_dir: Path, total_configs: int, best_configs: int, 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"{total_configs}")
+        summary_table.add_row("Optimized Configs:", f"{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
+        ))

nord_config_generator-1.0.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: nord-config-generator
+Version: 1.0.0
+Summary: A command-line tool for generating optimized NordVPN WireGuard configurations.
+Author-email: Ahmed Touhami <mustafachyi272@gmail.com>
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: aiofiles>=0.8.0
+Requires-Dist: rich>=12.0.0
+
+# NordVPN WireGuard Configuration Generator
+
+A command-line tool for generating optimized NordVPN WireGuard configurations.
+
+## Project Philosophy: A Focus on Quality
+
+This project has been fundamentally refocused. Previously, multiple versions existed across several programming languages. This approach divided development effort and resulted in inconsistent quality.
+
+The new directive is singular: to provide one exceptionally engineered tool that is robust, maintainable, and correct.
+
+To this end, all previous language implementations have been archived. Development is now concentrated on two platforms:
+
+1.  **This Command-Line Tool:** A complete rewrite in Python, packaged for professional use.
+2.  **A Web Interface:** For users who require a graphical frontend.
+
+This consolidated effort ensures a higher standard of quality and a more reliable end-product.
+
+## Core Capabilities
+
+*   **Package Distribution:** The tool is a proper command-line application, installable via PyPI. This eliminates manual dependency management.
+*   **Performance:** Asynchronous architecture processes the entire NordVPN server list in seconds.
+*   **Optimization:** Intelligently sorts servers by current load and geographic proximity to the user, generating configurations for the most performant connections.
+*   **Structured Output:** Automatically creates a clean directory structure containing standard configurations, a `best_configs` folder for optimal servers per location, and a `servers.json` file with detailed metadata for analysis.
+*   **Interactive and Non-Interactive:** A guided TUI for interactive use. The core logic is structured to be scriptable.
+
+## Installation
+
+Prerequisites: Python 3.8+
+
+Install the package using `pip`:
+
+```bash
+pip install nord-config-generator
+```
+
+## Usage
+
+Execute the installed application:
+
+```bash
+nord-generator
+```
+
+The application will prompt for the required access token and configuration preferences.
+
+## Web Version
+
+A graphical alternative is available for direct use in a web browser.
+
+*   **Current Version:** [https://nord-configs.selfhoster.nl/](https://nord-configs.selfhoster.nl/)
+*   **Legacy Version:** [https://wg-nord.pages.dev/](https://wg-nord.pages.dev/)
+
+## Support
+
+Project visibility and continued development are supported by two actions:
+
+1.  **Star the Repository:** Starring the project on GitHub increases its visibility.
+2.  **NordVPN Referral:** Using the referral link for new subscriptions provides support at no additional cost. Link: [https://ref.nordvpn.com/MXIVDoJGpKT](https://ref.nordvpn.com/MXIVDoJGpKT)
+
+## License
+
+This project is distributed under the GNU General Public License v3.0. See the `LICENSE` file for full details.

nord_config_generator-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+nord_config_generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nord_config_generator/main.py,sha256=P_xPIeXwUn4FJNPjR7aEun0EfL5vbHko3IOu4bnxfdI,12740
+nord_config_generator/ui.py,sha256=YEnSy9ltwul-3KzmEKLA3pynD29eEEf7hikzqRuI_l4,2838
+nord_config_generator-1.0.0.dist-info/METADATA,sha256=m1GQxkfmHG63UuylocH7M4leju66BObnmTirtlF-A10,3592
+nord_config_generator-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nord_config_generator-1.0.0.dist-info/entry_points.txt,sha256=NEVrNutXaNQAPTdWa9R5iZfdpVKZ_RYCYqR8hWJBv2Q,78
+nord_config_generator-1.0.0.dist-info/top_level.txt,sha256=wGNt1MATKpHqIKJ3G0ByTkE2thqRe6xPZWrIU0FstSo,22
+nord_config_generator-1.0.0.dist-info/RECORD,,

nord_config_generator-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nord_config_generator-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nord-generator = nord_config_generator.main:cli_entry_point

nord_config_generator-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nord_config_generator