nord-config-generator 1.0.0__tar.gz → 1.0.2__tar.gz

{nord_config_generator-1.0.0 → nord_config_generator-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nord-config-generator
-Version: 1.0.0
+Version: 1.0.2
 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
@@ -10,11 +10,11 @@ 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: aiofiles>=0.8.0
-Requires-Dist: rich>=12.0.0
+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 Configuration Generator
 
@@ -39,11 +39,11 @@ This consolidated effort ensures a higher standard of quality and a more reliabl
 *   **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.
+*   **Interactive and Non-Interactive:** A guided rich-CLI for interactive use. The core logic is structured to be scriptable.
 
 ## Installation
 
-Prerequisites: Python 3.8+
+Prerequisites: Python 3.9+
 
 Install the package using `pip`:
 
@@ -53,14 +53,24 @@ pip install nord-config-generator
 
 ## Usage
 
-Execute the installed application:
+### Generate Configurations (Default Action)
+
+Execute the application without any arguments. This is the primary function.
 
 ```bash
-nord-generator
+nordgen
 ```
 
 The application will prompt for the required access token and configuration preferences.
 
+### Retrieve Private Key
+
+To retrieve and display your NordLynx private key without generating configurations, use the `get-key` command:
+
+```bash
+nordgen get-key
+```
+
 ## Web Version
 
 A graphical alternative is available for direct use in a web browser.

{nord_config_generator-1.0.0 → nord_config_generator-1.0.2}/README.md

@@ -21,11 +21,11 @@ This consolidated effort ensures a higher standard of quality and a more reliabl
 *   **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.
+*   **Interactive and Non-Interactive:** A guided rich-CLI for interactive use. The core logic is structured to be scriptable.
 
 ## Installation
 
-Prerequisites: Python 3.8+
+Prerequisites: Python 3.9+
 
 Install the package using `pip`:
 
@@ -35,14 +35,24 @@ pip install nord-config-generator
 
 ## Usage
 
-Execute the installed application:
+### Generate Configurations (Default Action)
+
+Execute the application without any arguments. This is the primary function.
 
 ```bash
-nord-generator
+nordgen
 ```
 
 The application will prompt for the required access token and configuration preferences.
 
+### Retrieve Private Key
+
+To retrieve and display your NordLynx private key without generating configurations, use the `get-key` command:
+
+```bash
+nordgen get-key
+```
+
 ## Web Version
 
 A graphical alternative is available for direct use in a web browser.

{nord_config_generator-1.0.0 → nord_config_generator-1.0.2}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nord-config-generator"
-version = "1.0.0"
+version = "1.0.2"
 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.8"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
@@ -20,9 +20,9 @@ classifiers = [
     "Environment :: Console",
 ]
 dependencies = [
-    "aiohttp>=3.8.0",
-    "aiofiles>=0.8.0",
-    "rich>=12.0.0",
+    "aiohttp>=3.12.14, <4.0",
+    "aiofiles>=24.1.0, <25.0",
+    "rich>=14.0.0, <15.0",
 ]
 
 [project.urls]
@@ -30,4 +30,4 @@ dependencies = [
 "Bug Tracker" = "https://github.com/mustafachyi/NordVPN-WireGuard-Config-Generator/issues"
 
 [project.scripts]
-nord-generator = "nord_config_generator.main:cli_entry_point"
+nordgen = "nord_config_generator.main:cli_entry_point"

nord_config_generator-1.0.2/src/nord_config_generator/main.py

@@ -0,0 +1,343 @@
+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
+
+@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"
+    COUNTRIES_API_URL = f"{NORD_API_BASE_URL}/servers/countries"
+
+    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': 9000, 'filters[servers_technologies][identifier]': 'wireguard_udp'}
+        data = await self._get(url, params=params)
+        return data if isinstance(data, list) else []
+
+    async def get_countries(self) -> List[Dict[str, Any]]:
+        data = await self._get(self.COUNTRIES_API_URL)
+        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
+
+    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, countries_data = await self._fetch_remote_data()
+        if not user_location or not all_servers_data or not countries_data:
+            return None
+
+        country_code_map = {country['name']: country['code'].lower() for country in countries_data}
+        processed_servers = await self._process_server_data(all_servers_data, user_location, country_code_map)
+        
+        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]], List[Dict[str, Any]]]:
+        with self._console.create_progress_bar() as progress:
+            task = progress.add_task("Fetching remote data...", total=3)
+            user_location, all_servers_data, countries_data = await asyncio.gather(
+                self._api_client.get_user_geolocation(),
+                self._api_client.get_all_servers(),
+                self._api_client.get_countries()
+            )
+            progress.update(task, advance=3)
+        return user_location, all_servers_data, countries_data
+
+    async def _process_server_data(self, all_servers_data: List[Dict[str, Any]], user_location: Tuple[float, float], country_code_map: Dict[str, str]) -> List[Server]:
+        loop = asyncio.get_running_loop()
+        parse_func = partial(self._parse_server_data, user_location=user_location, country_code_map=country_code_map)
+        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):
+        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 = [self._create_save_task(s, 'configs', progress, task_all) for s in sorted_servers]
+            save_tasks.extend([self._create_save_task(s, 'best_configs', progress, task_best) for s in best_servers.values()])
+            
+            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_save_task(self, server: Server, subfolder: str, progress, task_id):
+        config_str = self._generate_wireguard_config_string(server, self._preferences, self._private_key)
+        path = self._output_dir / subfolder / self._sanitize_path_part(server.country) / self._sanitize_path_part(server.city)
+        filename = self._generate_compliant_filename(server)
+        return self._save_config_file(config_str, path, filename, progress, task_id)
+
+    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 _generate_compliant_filename(server: Server) -> str:
+        server_number_match = re.search(r'\d+$', server.name)
+        if not server_number_match:
+            fallback_name = f"wg{server.station.replace('.', '')}"
+            return f"{fallback_name[:15]}.conf"
+        
+        server_number = server_number_match.group(0)
+        base_name = f"{server.country_code}{server_number}"
+        return f"{base_name[: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], country_code_map: Dict[str, str]) -> Optional[Server]:
+        try:
+            location = server_data['locations'][0]
+            country_name = location['country']['name']
+            country_code = country_code_map.get(country_name)
+            if not country_code:
+                return None
+
+            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_name, country_code=country_code,
+                city=location['country'].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
+
+    @staticmethod
+    def _sanitize_path_part(part: str) -> str:
+        return re.sub(r'[<>:"/\\|?*\0]', '', part.lower().replace(' ', '_')).replace('#', '')
+
+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")
+        dns = dns_input if dns_input and re.match(r'^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$', dns_input) else defaults.dns
+
+        use_ip = user_input.get("endpoint_type", "").lower() == 'y'
+
+        keepalive = defaults.persistent_keepalive
+        keepalive_input = user_input.get("keepalive")
+        if keepalive_input and keepalive_input.isdigit():
+            keepalive_val = int(keepalive_input)
+            if 15 <= keepalive_val <= 120:
+                keepalive = keepalive_val
+        
+        return UserPreferences(dns=dns, use_ip_for_endpoint=use_ip, persistent_keepalive=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)
+        if not re.match(r'^[a-fA-F0-9]{64}$', token):
+            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.0 → nord_config_generator-1.0.2}/src/nord_config_generator/ui.py

@@ -4,8 +4,12 @@ from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeEl
 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({
@@ -27,7 +31,7 @@ class ConsoleManager:
     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:
+    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): ")
@@ -48,13 +52,17 @@ class ConsoleManager:
             transient=transient
         )
 
-    def print_summary(self, output_dir: Path, total_configs: int, best_configs: int, elapsed_time: float):
+    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"{total_configs}")
-        summary_table.add_row("Optimized Configs:", f"{best_configs}")
+        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(

{nord_config_generator-1.0.0 → nord_config_generator-1.0.2}/src/nord_config_generator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nord-config-generator
-Version: 1.0.0
+Version: 1.0.2
 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
@@ -10,11 +10,11 @@ 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: aiofiles>=0.8.0
-Requires-Dist: rich>=12.0.0
+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 Configuration Generator
 
@@ -39,11 +39,11 @@ This consolidated effort ensures a higher standard of quality and a more reliabl
 *   **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.
+*   **Interactive and Non-Interactive:** A guided rich-CLI for interactive use. The core logic is structured to be scriptable.
 
 ## Installation
 
-Prerequisites: Python 3.8+
+Prerequisites: Python 3.9+
 
 Install the package using `pip`:
 
@@ -53,14 +53,24 @@ pip install nord-config-generator
 
 ## Usage
 
-Execute the installed application:
+### Generate Configurations (Default Action)
+
+Execute the application without any arguments. This is the primary function.
 
 ```bash
-nord-generator
+nordgen
 ```
 
 The application will prompt for the required access token and configuration preferences.
 
+### Retrieve Private Key
+
+To retrieve and display your NordLynx private key without generating configurations, use the `get-key` command:
+
+```bash
+nordgen get-key
+```
+
 ## Web Version
 
 A graphical alternative is available for direct use in a web browser.

nord_config_generator-1.0.2/src/nord_config_generator.egg-info/entry_points.txt

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

nord_config_generator-1.0.2/src/nord_config_generator.egg-info/requires.txt

@@ -0,0 +1,3 @@
+aiohttp<4.0,>=3.12.14
+aiofiles<25.0,>=24.1.0
+rich<15.0,>=14.0.0

nord_config_generator-1.0.0/src/nord_config_generator/main.py

@@ -1,282 +0,0 @@
-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-1.0.0/src/nord_config_generator.egg-info/entry_points.txt

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

nord_config_generator-1.0.0/src/nord_config_generator.egg-info/requires.txt

@@ -1,3 +0,0 @@
-aiohttp>=3.8.0
-aiofiles>=0.8.0
-rich>=12.0.0