ipspot 0.3__py3-none-any.whl → 0.5__py3-none-any.whl

ipspot/ipv4.py

@@ -6,7 +6,7 @@ from typing import Union, Dict, List, Tuple
 import requests
 from requests.adapters import HTTPAdapter
 from urllib3.poolmanager import PoolManager
-from .utils import is_loopback
+from .utils import is_loopback, _get_json_standard, _attempt_with_retries
 from .params import REQUEST_HEADERS, IPv4API
 
 
@@ -53,6 +53,21 @@ class IPv4HTTPAdapter(HTTPAdapter):
             socket.getaddrinfo = self._original_getaddrinfo
 
 
+def _get_json_ipv4_forced(url: str, timeout: Union[float, Tuple[float, float]]) -> dict:
+    """
+    Send GET request with forced IPv4 using IPv4HTTPAdapter that returns JSON response.
+
+    :param url: API url
+    :param timeout: timeout value for API
+    """
+    with requests.Session() as session:
+        session.mount("http://", IPv4HTTPAdapter())
+        session.mount("https://", IPv4HTTPAdapter())
+        response = session.get(url, headers=REQUEST_HEADERS, timeout=timeout)
+        response.raise_for_status()
+        return response.json()
+
+
 def is_ipv4(ip: str) -> bool:
     """
     Check if the given input is a valid IPv4 address.
@@ -81,8 +96,8 @@ def get_private_ipv4() -> Dict[str, Union[bool, Dict[str, str], str]]:
         return {"status": False, "error": str(e)}
 
 
-def _ipsb_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-               =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ip_sb_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ip.sb.
 
@@ -90,30 +105,139 @@ def _ipsb_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        with requests.Session() as session:
-            response = session.get("https://api-ipv4.ip.sb/geoip", headers=REQUEST_HEADERS, timeout=timeout)
-            response.raise_for_status()
-            data = response.json()
-            result = {"status": True, "data": {"ip": data.get("ip"), "api": "ip.sb"}}
-            if geo:
-                geo_data = {
-                    "city": data.get("city"),
-                    "region": data.get("region"),
-                    "country": data.get("country"),
-                    "country_code": data.get("country_code"),
-                    "latitude": data.get("latitude"),
-                    "longitude": data.get("longitude"),
-                    "organization": data.get("organization"),
-                    "timezone": data.get("timezone")
-                }
-                result["data"].update(geo_data)
-            return result
+        data = _get_json_standard(url="https://api-ipv4.ip.sb/geoip", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ip.sb"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region"),
+                "country": data.get("country"),
+                "country_code": data.get("country_code"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": data.get("organization"),
+                "timezone": data.get("timezone")
+            }
+            result["data"].update(geo_data)
+        return result
     except Exception as e:
         return {"status": False, "error": str(e)}
 
 
-def _ipapi_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ipleak_net_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                     =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using ipleak.net.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_standard(url="https://ipv4.ipleak.net/json/", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ipleak.net"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city_name"),
+                "region": data.get("region_name"),
+                "country": data.get("country_name"),
+                "country_code": data.get("country_code"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": data.get("isp_name"),
+                "timezone": data.get("time_zone")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _my_ip_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using my-ip.io.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_standard(url="https://api4.my-ip.io/v2/ip.json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "my-ip.io"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region"),
+                "country": data.get("country", {}).get("name"),
+                "country_code": data.get("country", {}).get("code"),
+                "latitude": data.get("location", {}).get("lat"),
+                "longitude": data.get("location", {}).get("lon"),
+                "organization": data.get("asn", {}).get("name"),
+                "timezone": data.get("timeZone")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _ifconfig_co_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]  # very low rate limit
+                      =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using ifconfig.co.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://ifconfig.co/json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ifconfig.co"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region_name"),
+                "country": data.get("country"),
+                "country_code": data.get("country_iso"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": data.get("asn_org"),
+                "timezone": data.get("time_zone")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _ipapi_co_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using ipapi.co.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://ipapi.co/json/", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ipapi.co"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region"),
+                "country": data.get("country_name"),
+                "country_code": data.get("country_code"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": data.get("org"),
+                "timezone": data.get("timezone")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _ip_api_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                     =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ip-api.com.
 
@@ -121,34 +245,29 @@ def _ipapi_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        with requests.Session() as session:
-            session.mount("http://", IPv4HTTPAdapter())
-            session.mount("https://", IPv4HTTPAdapter())
-            response = session.get("http://ip-api.com/json/", headers=REQUEST_HEADERS, timeout=timeout)
-            response.raise_for_status()
-            data = response.json()
-            if data.get("status") != "success":
-                return {"status": False, "error": "ip-api lookup failed"}
-            result = {"status": True, "data": {"ip": data.get("query"), "api": "ip-api.com"}}
-            if geo:
-                geo_data = {
-                    "city": data.get("city"),
-                    "region": data.get("regionName"),
-                    "country": data.get("country"),
-                    "country_code": data.get("countryCode"),
-                    "latitude": data.get("lat"),
-                    "longitude": data.get("lon"),
-                    "organization": data.get("org"),
-                    "timezone": data.get("timezone")
-                }
-                result["data"].update(geo_data)
-            return result
+        data = _get_json_ipv4_forced(url="http://ip-api.com/json/", timeout=timeout)
+        if data.get("status") != "success":
+            return {"status": False, "error": "ip-api lookup failed"}
+        result = {"status": True, "data": {"ip": data["query"], "api": "ip-api.com"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("regionName"),
+                "country": data.get("country"),
+                "country_code": data.get("countryCode"),
+                "latitude": data.get("lat"),
+                "longitude": data.get("lon"),
+                "organization": data.get("org"),
+                "timezone": data.get("timezone")
+            }
+            result["data"].update(geo_data)
+        return result
     except Exception as e:
         return {"status": False, "error": str(e)}
 
 
-def _ipinfo_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                 =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ipinfo_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                    =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipinfo.io.
 
@@ -156,27 +275,50 @@ def _ipinfo_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        with requests.Session() as session:
-            session.mount("http://", IPv4HTTPAdapter())
-            session.mount("https://", IPv4HTTPAdapter())
-            response = session.get("https://ipinfo.io/json", headers=REQUEST_HEADERS, timeout=timeout)
-            response.raise_for_status()
-            data = response.json()
-            result = {"status": True, "data": {"ip": data.get("ip"), "api": "ipinfo.io"}}
-            if geo:
-                loc = data.get("loc", "").split(",")
-                geo_data = {
-                    "city": data.get("city"),
-                    "region": data.get("region"),
-                    "country": None,
-                    "country_code": data.get("country"),
-                    "latitude": float(loc[0]) if len(loc) == 2 else None,
-                    "longitude": float(loc[1]) if len(loc) == 2 else None,
-                    "organization": data.get("org"),
-                    "timezone": data.get("timezone")
-                }
-                result["data"].update(geo_data)
-            return result
+        data = _get_json_ipv4_forced(url="https://ipinfo.io/json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ipinfo.io"}}
+        if geo:
+            loc = data.get("loc", "").split(",")
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region"),
+                "country": None,
+                "country_code": data.get("country"),
+                "latitude": float(loc[0]) if len(loc) == 2 else None,
+                "longitude": float(loc[1]) if len(loc) == 2 else None,
+                "organization": data.get("org"),
+                "timezone": data.get("timezone")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _reallyfreegeoip_org_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                              =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using reallyfreegeoip.org.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://reallyfreegeoip.org/json/", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "reallyfreegeoip.org"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region_name"),
+                "country": data.get("country_name"),
+                "country_code": data.get("country_code"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": None,  # does not provide organization
+                "timezone": data.get("time_zone")
+            }
+            result["data"].update(geo_data)
+        return result
     except Exception as e:
         return {"status": False, "error": str(e)}
 
@@ -190,30 +332,27 @@ def _ident_me_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        with requests.Session() as session:
-            response = session.get("https://4.ident.me/json", headers=REQUEST_HEADERS, timeout=timeout)
-            response.raise_for_status()
-            data = response.json()
-            result = {"status": True, "data": {"ip": data.get("ip"), "api": "ident.me"}}
-            if geo:
-                geo_data = {
-                    "city": data.get("city"),
-                    "region": None,
-                    "country": data.get("country"),
-                    "country_code": data.get("cc"),
-                    "latitude": data.get("latitude"),
-                    "longitude": data.get("longitude"),
-                    "organization": data.get("aso"),
-                    "timezone": data.get("tz")
-                }
-                result["data"].update(geo_data)
-            return result
+        data = _get_json_standard(url="https://4.ident.me/json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ident.me"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": None,
+                "country": data.get("country"),
+                "country_code": data.get("cc"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": data.get("aso"),
+                "timezone": data.get("tz")
+            }
+            result["data"].update(geo_data)
+        return result
     except Exception as e:
         return {"status": False, "error": str(e)}
 
 
-def _tnedime_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                  =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _tnedi_me_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
+                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using tnedi.me.
 
@@ -221,53 +360,284 @@ def _tnedime_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        with requests.Session() as session:
-            response = session.get("https://4.tnedi.me/json", headers=REQUEST_HEADERS, timeout=timeout)
-            response.raise_for_status()
-            data = response.json()
-            result = {"status": True, "data": {"ip": data.get("ip"), "api": "tnedi.me"}}
-            if geo:
-                geo_data = {
-                    "city": data.get("city"),
-                    "region": None,
-                    "country": data.get("country"),
-                    "country_code": data.get("cc"),
-                    "latitude": data.get("latitude"),
-                    "longitude": data.get("longitude"),
-                    "organization": data.get("aso"),
-                    "timezone": data.get("tz")
-                }
-                result["data"].update(geo_data)
-            return result
+        data = _get_json_standard(url="https://4.tnedi.me/json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "tnedi.me"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": None,
+                "country": data.get("country"),
+                "country_code": data.get("cc"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": data.get("aso"),
+                "timezone": data.get("tz")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _myip_la_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+                  ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using myip.la.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://api.myip.la/en?json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "myip.la"}}
+        if geo:
+            loc = data.get("location", {})
+            geo_data = {
+                "city": loc.get("city"),
+                "region": loc.get("province"),
+                "country": loc.get("country_name"),
+                "country_code": loc.get("country_code"),
+                "latitude": float(loc.get("latitude")) if loc.get("latitude") else None,
+                "longitude": float(loc.get("longitude")) if loc.get("longitude") else None,
+                "organization": None,
+                "timezone": None
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _freeipapi_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+                        ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using freeipapi.com.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://freeipapi.com/api/json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ipAddress"], "api": "freeipapi.com"}}
+        if geo:
+            geo_data = {
+                "city": data.get("cityName"),
+                "region": data.get("regionName"),
+                "country": data.get("countryName"),
+                "country_code": data.get("countryCode"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": None,
+                "timezone": data.get("timeZone")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _ipquery_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+                     ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using ipquery.io.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://api.ipquery.io/?format=json", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ipquery.io"}}
+        if geo:
+            loc = data.get("location", {})
+            isp = data.get("isp", {})
+            geo_data = {
+                "city": loc.get("city"),
+                "region": loc.get("state"),
+                "country": loc.get("country"),
+                "country_code": loc.get("country_code"),
+                "latitude": loc.get("latitude"),
+                "longitude": loc.get("longitude"),
+                "timezone": loc.get("timezone"),
+                "organization": isp.get("org"),
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _ipwho_is_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using ipwho.is.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_ipv4_forced(url="https://ipwho.is", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["ip"], "api": "ipwho.is"}}
+        if geo:
+            connection = data.get("connection", {})
+            timezone = data.get("timezone", {})
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("region"),
+                "country": data.get("country"),
+                "country_code": data.get("country_code"),
+                "latitude": data.get("latitude"),
+                "longitude": data.get("longitude"),
+                "organization": connection.get("org"),
+                "timezone": timezone.get("id")
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
+def _wtfismyip_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+                        ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Get public IP and geolocation using wtfismyip.com.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_standard(url="https://json.ipv4.wtfismyip.com", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["YourFuckingIPAddress"], "api": "wtfismyip.com"}}
+        if geo:
+            geo_data = {
+                "city": data.get("YourFuckingCity"),
+                "region": None,
+                "country": data.get("YourFuckingCountry"),
+                "country_code": data.get("YourFuckingCountryCode"),
+                "latitude": None,
+                "longitude": None,
+                "organization": data.get("YourFuckingISP"),
+                "timezone": None
+            }
+            result["data"].update(geo_data)
+        return result
     except Exception as e:
         return {"status": False, "error": str(e)}
 
 
-def get_public_ipv4(api: IPv4API=IPv4API.AUTO, geo: bool=False,
-                    timeout: Union[float, Tuple[float, float]]=5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+IPV4_API_MAP = {
+    IPv4API.IFCONFIG_CO: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ifconfig_co_ipv4
+    },
+    IPv4API.IDENT_ME: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _ident_me_ipv4
+    },
+    IPv4API.TNEDI_ME: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _tnedi_me_ipv4
+    },
+    IPv4API.IP_SB: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _ip_sb_ipv4
+    },
+    IPv4API.IPLEAK_NET: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _ipleak_net_ipv4
+    },
+    IPv4API.MY_IP_IO: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _my_ip_io_ipv4
+    },
+    IPv4API.IP_API_COM: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ip_api_com_ipv4
+    },
+    IPv4API.IPINFO_IO: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ipinfo_io_ipv4
+    },
+    IPv4API.IPAPI_CO: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ipapi_co_ipv4
+    },
+    IPv4API.REALLYFREEGEOIP_ORG: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _reallyfreegeoip_org_ipv4
+    },
+    IPv4API.FREEIPAPI_COM: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _freeipapi_com_ipv4,
+    },
+    IPv4API.MYIP_LA: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _myip_la_ipv4,
+    },
+    IPv4API.IPQUERY_IO: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ipquery_io_ipv4,
+    },
+    IPv4API.IPWHO_IS: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ipwho_is_ipv4,
+    },
+    IPv4API.WTFISMYIP_COM: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _wtfismyip_com_ipv4
+    },
+}
+
+
+def get_public_ipv4(api: IPv4API=IPv4API.AUTO_SAFE, geo: bool=False,
+                    timeout: Union[float, Tuple[float, float]]=5,
+                    max_retries: int = 0,
+                    retry_delay: float = 1.0) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IPv4 and geolocation info based on the selected API.
 
     :param api: public IPv4 API
     :param geo: geolocation flag
     :param timeout: timeout value for API
+    :param max_retries: number of retries
+    :param retry_delay: delay between retries (in seconds)
     """
-    api_map = {
-        IPv4API.IDENTME: _ident_me_ipv4,
-        IPv4API.TNEDIME: _tnedime_ipv4,
-        IPv4API.IPSB: _ipsb_ipv4,
-        IPv4API.IPAPI: _ipapi_ipv4,
-        IPv4API.IPINFO: _ipinfo_ipv4,
-    }
-
-    if api == IPv4API.AUTO:
-        for _, func in api_map.items():
-            result = func(geo=geo, timeout=timeout)
+    if api in [IPv4API.AUTO, IPv4API.AUTO_SAFE]:
+        for _, api_data in IPV4_API_MAP.items():
+            if api == IPv4API.AUTO_SAFE and not api_data["thread_safe"]:
+                continue
+            func = api_data["function"]
+            result = _attempt_with_retries(
+                func=func,
+                max_retries=max_retries,
+                retry_delay=retry_delay,
+                geo=geo,
+                timeout=timeout)
             if result["status"]:
                 return result
         return {"status": False, "error": "All attempts failed."}
     else:
-        func = api_map.get(api)
-        if func:
-            return func(geo=geo, timeout=timeout)
+        api_data = IPV4_API_MAP.get(api)
+        if api_data:
+            func = api_data["function"]
+            return _attempt_with_retries(
+                func=func,
+                max_retries=max_retries,
+                retry_delay=retry_delay,
+                geo=geo,
+                timeout=timeout)
         return {"status": False, "error": "Unsupported API: {api}".format(api=api)}