remove duplicate existing relays check

nostr_relay_discovery.py

@@ -106,7 +106,7 @@ class NostrRelayDiscovery:
     
     def normalize_relay_url(self, url: str) -> str:
         """Normalize relay URL (remove trailing slashes, etc.)"""
-        url = url.strip()
+        url = url.strip().lower()
         match = re.match(r'^(wss://[^/]+)/?$', url)
 
         if match:
@@ -307,35 +307,14 @@ class NostrRelayDiscovery:
             logger.info(f"Found {len(existing_relays)} existing functioning relays to verify")
             
             if not existing_relays:
-                logger.info("No existing functioning relays found, starting fresh")
+                logger.info("No existing relays found, starting fresh")
                 self.to_visit.append((self.initial_relay, 0))
                 self.to_visit_set.add(self.initial_relay)
                 return False
-            
-            # Verify existing relays still work
-            verified_relays = await self.verify_existing_relays(existing_relays)
-            
-            if verified_relays:
-                logger.info(f"Successfully verified {len(verified_relays)} existing relays")
-                # Use verified relays as starting points for discovery
-                for relay in verified_relays:
-                    self.to_visit.append((relay, 0))
-                    self.to_visit_set.add(relay)
-                    self.functioning_relays.add(relay)
-                    self.stats.functioning_relays += 1
-                
-                # Also preserve other statistics if available
-                if 'statistics' in data:
-                    old_stats = data['statistics']
-                    self.stats.total_relays_found = old_stats.get('total_relays_found', len(verified_relays))
-                    self.stats.events_processed = old_stats.get('events_processed', 0)
-                
-                return True
             else:
-                logger.warning("No existing relays could be verified, starting fresh")
-                self.to_visit.append((self.initial_relay, 0))
-                self.to_visit_set.add(self.initial_relay)
-                return False
+                logger.info("Existing relays found, building on the previous results")
+                self.to_visit.append((existing_relays, 0))
+                self.to_visit_set.update(existing_relays)
                 
         except Exception as e:
             logger.error(f"Error loading existing results: {e}")
@@ -344,46 +323,6 @@ class NostrRelayDiscovery:
             self.to_visit_set.add(self.initial_relay)
             return False
     
-    async def verify_existing_relays(self, existing_relays: List[str]) -> List[str]:
-        """Verify that existing relays still work and filter out non-working ones"""
-        verified_relays = []
-        
-        logger.info(f"Verifying {len(existing_relays)} existing relays...")
-        
-        # Test relays in batches to avoid overwhelming connections
-        batch_size = 10
-        for i in range(0, len(existing_relays), batch_size):
-            batch = existing_relays[i:i + batch_size]
-            batch_tasks = []
-            
-            for relay in batch:
-                if self.is_valid_relay_url(relay):
-                    batch_tasks.append(self.test_relay_connection(relay))
-                else:
-                    logger.warning(f"Invalid relay URL in existing results: {relay}")
-                    self.stats.existing_relays_failed += 1
-            
-            if batch_tasks:
-                # Run batch tests concurrently
-                batch_results = await asyncio.gather(*batch_tasks, return_exceptions=True)
-                
-                for j, result in enumerate(batch_results):
-                    relay = batch[j]
-                    if isinstance(result, bool) and result:
-                        verified_relays.append(relay)
-                        self.stats.existing_relays_verified += 1
-                        logger.info(f"✓ Verified existing relay: {relay}")
-                    else:
-                        self.stats.existing_relays_failed += 1
-                        logger.warning(f"✗ Existing relay failed verification: {relay}")
-            
-            # Small delay between batches to be nice to the relays
-            if i + batch_size < len(existing_relays):
-                await asyncio.sleep(0.5)
-        
-        logger.info(f"Verification complete: {len(verified_relays)}/{len(existing_relays)} relays still functioning")
-        return verified_relays
-    
     async def discover_relays(self) -> Set[str]:
         """Main discovery method using breadth-first search"""
         # First, try to load existing results and verify them

relays_geo_lookup.sh

@@ -7,9 +7,7 @@ if [ "$#" -ne 1 ]; then
 fi
 
 output_file="$1"
-if [ ! -f "$output_file" ] || [ ! -s "$output_file" ]; then
-    echo "Relay URL,Latitude,Longitude" > "$output_file"
-fi
+echo "Relay URL,Latitude,Longitude" > "$output_file"
 
 while IFS= read -r url; do