fix(networking): fix ip-lookup fallback chain

Closes #3309.

Each provider in `get_external_ip` was wrapped in
`except ExternalIPNotFound`, but none of the underlying calls
(`requests.get`, `ip_to_int`, `os.popen`+`readline`,
`urllib.request.urlopen`, `json.loads`, wikipedia header lookup)
ever raise `ExternalIPNotFound`. As a result the first failing
provider crashed the entire function instead of falling through
to the next one.

Catch the exceptions that can actually occur:
  * RequestException  — for `requests.get` failures
  * AddrFormatError   — for malformed IPs
  * OSError           — for `os.popen`/curl failures
  * URLError          — for urllib failures
  * ValueError        — for json + int parse failures
  * KeyError          — for the wikipedia header
  * AssertionError    — for the isinstance guards
  * ExternalIPNotFound — kept for backward compat

Three regression tests cover: AWS connection error → curl
fallthrough, malformed AWS IP → curl fallthrough, and
all-providers-exhausted → ExternalIPNotFound.

Author: ArtificialXai

bittensor/utils/networking.py

@@ -2,6 +2,7 @@
 
 import os
 from typing import Optional
+from urllib import error as urllib_error
 from urllib import request as urllib_request
 
 import netaddr
@@ -13,6 +14,22 @@ class ExternalIPNotFound(Exception):
     """Raised if we cannot attain your external ip from CURL/URLLIB/IPIFY/AWS"""
 
 
+# Exceptions each provider in `get_external_ip` can raise on failure. Caught per
+# provider so that a single failing lookup falls through to the next one instead
+# of crashing the whole function. Kept as a tuple so the list stays consistent
+# across providers.
+_IP_LOOKUP_EXCEPTIONS = (
+    requests.exceptions.RequestException,
+    netaddr.core.AddrFormatError,
+    OSError,
+    urllib_error.URLError,
+    ValueError,
+    KeyError,
+    AssertionError,
+    ExternalIPNotFound,
+)
+
+
 def int_to_ip(int_val: int) -> str:
     """Maps an integer to a unique ip-string
 
@@ -68,7 +85,7 @@ def get_external_ip() -> str:
         external_ip = requests.get("https://checkip.amazonaws.com").text.strip()
         assert isinstance(ip_to_int(external_ip), int)
         return str(external_ip)
-    except ExternalIPNotFound:
+    except _IP_LOOKUP_EXCEPTIONS:
         pass
 
     # --- Try ipconfig.
@@ -78,7 +95,7 @@ def get_external_ip() -> str:
         process.close()
         assert isinstance(ip_to_int(external_ip), int)
         return str(external_ip)
-    except ExternalIPNotFound:
+    except _IP_LOOKUP_EXCEPTIONS:
         pass
 
     # --- Try ipinfo.
@@ -88,7 +105,7 @@ def get_external_ip() -> str:
         process.close()
         assert isinstance(ip_to_int(external_ip), int)
         return str(external_ip)
-    except ExternalIPNotFound:
+    except _IP_LOOKUP_EXCEPTIONS:
         pass
 
     # --- Try myip.dnsomatic
@@ -98,23 +115,23 @@ def get_external_ip() -> str:
         process.close()
         assert isinstance(ip_to_int(external_ip), int)
         return str(external_ip)
-    except ExternalIPNotFound:
+    except _IP_LOOKUP_EXCEPTIONS:
         pass
 
     # --- Try urllib ipv6
     try:
         external_ip = urllib_request.urlopen("https://ident.me").read().decode("utf8")
         assert isinstance(ip_to_int(external_ip), int)
         return str(external_ip)
-    except ExternalIPNotFound:
+    except _IP_LOOKUP_EXCEPTIONS:
         pass
 
     # --- Try Wikipedia
     try:
         external_ip = requests.get("https://www.wikipedia.org").headers["X-Client-IP"]
         assert isinstance(ip_to_int(external_ip), int)
         return str(external_ip)
-    except ExternalIPNotFound:
+    except _IP_LOOKUP_EXCEPTIONS:
         pass
 
     raise ExternalIPNotFound

tests/unit_tests/utils/test_networking.py

@@ -161,6 +161,79 @@ def urlopen(self):
                 assert utils.networking.get_external_ip()
 
 
+# Regression for https://github.com/latent-to/bittensor/issues/3309:
+# providers that raise their real-world exceptions (not `ExternalIPNotFound`)
+# must be caught and allow the fallback chain to continue.
+def test_get_external_ip_aws_connection_error_falls_through_to_curl(mocker):
+    """AWS requests.ConnectionError should fall through to the curl provider."""
+    mocked_requests_get = mock.Mock(
+        side_effect=requests.exceptions.ConnectionError("no network"),
+    )
+    mocker.patch.object(requests, "get", mocked_requests_get)
+
+    class FakeProcess:
+        def readline(self):
+            return "203.0.113.7"
+
+        def close(self):
+            return None
+
+        def read(self):
+            return '{"ip": "203.0.113.7"}'
+
+    mocker.patch.object(os, "popen", mock.Mock(return_value=FakeProcess()))
+
+    assert utils.networking.get_external_ip() == "203.0.113.7"
+
+
+def test_get_external_ip_malformed_ip_falls_through(mocker):
+    """Malformed IP from AWS should raise AddrFormatError, not propagate."""
+    mocked_requests_get = mock.Mock(
+        return_value=mock.Mock(
+            **{"text": "not-an-ip"},
+        ),
+    )
+    mocker.patch.object(requests, "get", mocked_requests_get)
+
+    class FakeProcess:
+        def readline(self):
+            return "198.51.100.42"
+
+        def close(self):
+            return None
+
+        def read(self):
+            return '{"ip": "198.51.100.42"}'
+
+    mocker.patch.object(os, "popen", mock.Mock(return_value=FakeProcess()))
+
+    assert utils.networking.get_external_ip() == "198.51.100.42"
+
+
+def test_get_external_ip_all_providers_exhausted_raises(mocker):
+    """If every provider fails, the function must raise ExternalIPNotFound
+    (not the last underlying exception)."""
+    mocker.patch.object(
+        requests,
+        "get",
+        mock.Mock(side_effect=requests.exceptions.ConnectionError("no network")),
+    )
+    mocker.patch.object(
+        os,
+        "popen",
+        mock.Mock(side_effect=OSError("popen disabled")),
+    )
+    # Patch through the module's own imported name to avoid interference from
+    # other tests in this file that rebind `urllib.request` at module scope.
+    mocker.patch(
+        "bittensor.utils.networking.urllib_request.urlopen",
+        mock.Mock(side_effect=urllib.error.URLError("urlopen disabled")),
+    )
+
+    with pytest.raises(utils.networking.ExternalIPNotFound):
+        utils.networking.get_external_ip()
+
+
 # Test formatting WebSocket endpoint URL
 @pytest.mark.parametrize(
     "url, expected",