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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nord-config-generator
-Version: 1.0.1
+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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nord-config-generator"
-version = "1.0.1"
+version = "1.0.2"
 authors = [
   { name="Ahmed Touhami", email="mustafachyi272@gmail.com" },
 ]

{nord_config_generator-1.0.1 → nord_config_generator-1.0.2}/src/nord_config_generator/main.py

@@ -25,6 +25,7 @@ class Server:
     station: str
     load: int
     country: str
+    country_code: str
     city: str
     latitude: float
     longitude: float
@@ -45,6 +46,7 @@ class GenerationStats:
 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
@@ -73,6 +75,10 @@ class NordVpnApiClient:
         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):
@@ -108,11 +114,13 @@ class ConfigurationOrchestrator:
         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:
+        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
 
-        processed_servers = await self._process_server_data(all_servers_data, user_location)
+        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)
         
@@ -122,19 +130,20 @@ class ConfigurationOrchestrator:
         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]]]:
+    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=2)
-            user_location, all_servers_data = await asyncio.gather(
+            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_all_servers(),
+                self._api_client.get_countries()
             )
-            progress.update(task, advance=2)
-        return user_location, all_servers_data
+            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]) -> List[Server]:
+    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)
+        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)
@@ -174,7 +183,7 @@ class ConfigurationOrchestrator:
     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 = f"{self._sanitize_path_part(server.name)}.conf"
+        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):
@@ -184,15 +193,31 @@ class ConfigurationOrchestrator:
                 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]) -> Optional[Server]:
+    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'
@@ -204,7 +229,8 @@ class ConfigurationOrchestrator:
             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'),
+                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
             )

{nord_config_generator-1.0.1 → 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.1
+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