few fix

Author: eclipsevortex

subvortex/core/country/country.py

@@ -29,8 +29,8 @@
 # Per-API rate limits (seconds between calls)
 API_RATE_LIMITS = {
     "subvortex": 60,  # SubVortex API - conservative
-    "ipinfo": 86.4,  # Free tier: 1000 req/day = 86400s/1000 = 86.4s between calls - Highest accuracy (~99%)
-    "ip_api": 1.5,  # Free tier: 45 req/min = 1.33s between calls, use 1.5s for safety (https://ip-api.com/docs/unban) - Very high accuracy (~98%)
+    "ipinfo": 90,  # Free tier: 1000 req/day = 86400s/1000 = 86.4s between calls - Highest accuracy (~99%)
+    "ip_api": 5,  # Free tier: 45 req/min = 1.33s between calls, use 1.5s for safety (https://ip-api.com/docs/unban) - Very high accuracy (~98%)
     "country_is": 10,  # Free tier: 1 req/10 seconds per IP (https://country.is/) - Good accuracy (~95%)
     "my_api": 0,  # Custom API - Down!
 }
@@ -80,21 +80,28 @@ def get_country(ip: str):
 
         try:
             _last_call_time[api_name] = now
+
             country, reason = api_func(ip_ipv4)
             if country:
                 return country
+            
             if reason:
                 errors.append(f"{api_name}: {reason}")
 
+        except requests.HTTPError as e:
+            status_code = getattr(e.response, 'status_code', 'unknown')
+            errors.append(f"{api_name} ({status_code}): {e}")
+            
         except Exception as e:
             errors.append(f"{api_name}: {e}")
 
     # Build error message with rate limit info
     all_errors = errors + [
         f"{api}: {remaining:.0f}s cooldown" for api, remaining in rate_limited.items()
     ]
+
     raise CountryApiException(
-        f"All APIs failed for {ip_ipv4}: {'; '.join(all_errors)}", rate_limited
+        f"All APIs failed for {ip_ipv4} - {'; '.join(all_errors)}", rate_limited
     )
 
 

subvortex/core/metagraph/database.py

@@ -248,6 +248,32 @@ async def notify_state(self):
                 prefix=self.settings.logging_name,
             )
 
+    async def get_state(self):
+        """
+        Get the block of the last time the metagraph has been updated
+        """
+        # Ensure Redis connection is established before any operation.
+        await self.ensure_connection()
+
+        # Get a connected Redis client, configured with the correct DB index and prefix.
+        client = await self.get_client()
+
+        try:
+            raw = await client.get(self._key("state:metagraph"))
+            return raw
+
+        except Exception as ex:
+            btul.logging.error(
+                f"[get_last_updated] Failed to read last updated block: {ex}",
+                prefix=self.settings.logging_name,
+            )
+            btul.logging.debug(
+                f"[get_last_updated] Exception type: {type(ex).__name__}, Traceback:\n{traceback.format_exc()}",
+                prefix=self.settings.logging_name,
+            )
+
+        return 0
+    
     def _key(self, key: str):
         # Prefixes keys to namespace them under this service
         return f"{self.settings.key_prefix}:{key}"

subvortex/core/metagraph/metagraph.py

@@ -41,7 +41,6 @@ async def start(self):
         """
         registration_count = 0
         axons = {}
-        ready = False
         last_synced_block = 0
         sync_interval = self.settings.sync_interval
         has_missing_country = False
@@ -112,11 +111,13 @@ async def start(self):
                     # Get the last udpate
                     last_update = await self.database.get_neuron_last_updated()
 
+                    # Get the current state of the metagraph
+                    state = await self.database.get_state()
+
                     # Determine whether a resync is needed
                     time_to_resync = block - last_synced_block >= sync_interval
                     must_resync = (
-                        not ready
-                        or has_new_registration
+                        has_new_registration
                         or has_axons_changed
                         or has_missing_country
                         or time_to_resync
@@ -128,12 +129,12 @@ async def start(self):
                             "No changes detected; skipping sync.",
                             prefix=self.settings.logging_name,
                         )
-                        
+
                         # Notify listener the metagraph is ready
-                        ready = await self._notify_if_needed(ready)
+                        ready = await self._notify_if_needed(state == "ready")
 
                         continue
-                  
+
                     if has_axons_changed:
                         reason = "hotkey/IP changes detected"
                     elif has_missing_country:
@@ -271,6 +272,7 @@ async def _resync(self, last_update: bool) -> dict[str, str]:
                         f"⏰ Waiting {max_wait:.0f}s for all APIs to recover..."
                     )
                     await asyncio.sleep(max_wait)
+
                 else:
                     await asyncio.sleep(60)  # Default wait if no rate limit info