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

nord_config_generator/main.py

@@ -18,10 +18,6 @@ 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
@@ -29,6 +25,7 @@ class Server:
     station: str
     load: int
     country: str
+    country_code: str
     city: str
     latitude: float
     longitude: float
@@ -41,49 +38,49 @@ class UserPreferences:
     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)
+@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._session = aiohttp.ClientSession()
         self._console = console_manager
+        self._session: Optional[aiohttp.ClientSession] = None
 
-    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 __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"{NORD_API_BASE_URL}/users/services/credentials"
-        data = await self._get(url, headers={'Authorization': f'Basic {auth_header}'})
+        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"{NORD_API_BASE_URL}/servers"
+        url = f"{self.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 []
+        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(LOCATION_API_URL)
+        data = await self._get(self.LOCATION_API_URL)
         if not isinstance(data, dict):
             return None
         try:
@@ -93,190 +90,254 @@ class NordVpnApiClient:
             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()
+    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._api_client = api_client
         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(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}
+        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 _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 _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}"
 
-    def _parse_server_data(self, server_data: Dict[str, Any], user_location: Tuple[float, float]) -> Optional[Server]:
+    @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(
-                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'
+                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=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'])
+                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
 
-    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 _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('#', '')
 
-    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)
+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
 
-        sorted_servers = sorted(processed_servers, key=lambda s: (s.load, s.distance))
+        preferences = self._collect_user_preferences()
         
-        self._output_dir.mkdir(exist_ok=True)
-        servers_info, best_servers_by_location = {}, {}
+        self._console.clear()
         
-        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))
+        start_time = time.time()
+        orchestrator = ConfigurationOrchestrator(private_key, preferences, self._console, api_client)
+        output_dir = await orchestrator.generate()
+        elapsed_time = time.time() - start_time
         
-        self.generation_succeeded = True
-        return self._output_dir
+        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 is_valid_token_format(token: str) -> bool:
-    return bool(re.match(r'^[a-fA-F0-9]{64}$', token))
+    def _collect_user_preferences(self) -> UserPreferences:
+        defaults = UserPreferences()
+        user_input = self._console.get_preferences(defaults)
 
-async def main_async():
-    console = ConsoleManager()
-    api_client = NordVpnApiClient(console)
+        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
 
-    try:
-        console.clear()
-        console.print_title()
+        use_ip = user_input.get("endpoint_type", "").lower() == 'y'
 
-        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
+        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)
 
-        private_key = None
-        with console.create_progress_bar() as progress:
+    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 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)
+        if private_key:
+            self._console.print_message("success", "Token validated successfully.")
+            return private_key
         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()
+            self._console.print_message("error", "Token is invalid or could not be verified.")
+            return None
 
 def cli_entry_point():
     try:
-        asyncio.run(main_async())
+        app = Application()
+        asyncio.run(app.run(sys.argv[1:]))
     except KeyboardInterrupt:
         print("\nProcess interrupted by user.")
 
 if __name__ == "__main__":
-    cli_entry_point()
+    cli_entry_point()

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.dist-info → nord_config_generator-1.0.2.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+nord_config_generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nord_config_generator/main.py,sha256=0eoOR9rbwqI_BK445-wvRSDNuYj6jBwC04WSR4TT3AI,15604
+nord_config_generator/ui.py,sha256=r9ulCF3t8h9WlepXM4_LAdDLi8TFM9HufXrO95cMOOM,3148
+nord_config_generator-1.0.2.dist-info/METADATA,sha256=10zzx4oPvftR-M5v5bIwP3p2dp_RrIkTOy5_zisZP2w,3876
+nord_config_generator-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nord_config_generator-1.0.2.dist-info/entry_points.txt,sha256=TEZSrG2vKDWS4hcLAy-s65yjdxzcXAGbExHwWSYqd04,71
+nord_config_generator-1.0.2.dist-info/top_level.txt,sha256=wGNt1MATKpHqIKJ3G0ByTkE2thqRe6xPZWrIU0FstSo,22
+nord_config_generator-1.0.2.dist-info/RECORD,,

nord_config_generator-1.0.2.dist-info/entry_points.txt

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

nord_config_generator-1.0.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-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/entry_points.txt

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