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

ipspot/cli.py

@@ -4,7 +4,7 @@ import argparse
 from typing import Union, Tuple
 from art import tprint
 from .ipv4 import get_public_ipv4, get_private_ipv4
-from .utils import filter_parameter
+from .utils import _filter_parameter
 from .params import IPv4API, PARAMETERS_NAME_MAP
 from .params import IPSPOT_OVERVIEW, IPSPOT_REPO, IPSPOT_VERSION
 
@@ -17,14 +17,17 @@ def ipspot_info() -> None:  # pragma: no cover
     print("Repo : " + IPSPOT_REPO)
 
 
-def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO, geo: bool=False,
-                    timeout: Union[float, Tuple[float, float]]=5) -> None:  # pragma: no cover
+def display_ip_info(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) -> None:  # pragma: no cover
     """
     Print collected IP and location data.
 
     :param ipv4_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)
     """
     private_result = get_private_ipv4()
     print("Private IP:\n")
@@ -36,13 +39,18 @@ def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO, geo: bool=False,
         public_title += " and Location Info"
     public_title += ":\n"
     print(public_title)
-    public_result = get_public_ipv4(ipv4_api, geo=geo, timeout=timeout)
+    public_result = get_public_ipv4(
+        ipv4_api,
+        geo=geo,
+        timeout=timeout,
+        max_retries=max_retries,
+        retry_delay=retry_delay)
     if public_result["status"]:
         for name, parameter in sorted(public_result["data"].items()):
             print(
                 "  {name}: {parameter}".format(
                     name=PARAMETERS_NAME_MAP[name],
-                    parameter=filter_parameter(parameter)))
+                    parameter=_filter_parameter(parameter)))
     else:
         print("  Error: {public_result[error]}".format(public_result=public_result))
 
@@ -56,11 +64,13 @@ def main() -> None:  # pragma: no cover
         type=str.lower,
         choices=[
             x.value for x in IPv4API],
-        default=IPv4API.AUTO.value)
+        default=IPv4API.AUTO_SAFE.value)
     parser.add_argument('--info', help='info', nargs="?", const=1)
     parser.add_argument('--version', help='version', nargs="?", const=1)
     parser.add_argument('--no-geo', help='no geolocation data', nargs="?", const=1, default=False)
     parser.add_argument('--timeout', help='timeout for the API request', type=float, default=5.0)
+    parser.add_argument('--max-retries', help='number of retries', type=int, default=0)
+    parser.add_argument('--retry-delay', help='delay between retries (in seconds)', type=float, default=1.0)
 
     args = parser.parse_args()
     if args.version:
@@ -70,4 +80,9 @@ def main() -> None:  # pragma: no cover
     else:
         ipv4_api = IPv4API(args.ipv4_api)
         geo = not args.no_geo
-        display_ip_info(ipv4_api=ipv4_api, geo=geo, timeout=args.timeout)
+        display_ip_info(
+            ipv4_api=ipv4_api,
+            geo=geo,
+            timeout=args.timeout,
+            max_retries=args.max_retries,
+            retry_delay=args.retry_delay)

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]]
+                      =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,181 @@ 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 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,
+    },
+}
+
+
+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)}

ipspot/params.py

@@ -2,7 +2,7 @@
 """ipspot params."""
 from enum import Enum
 
-IPSPOT_VERSION = "0.3"
+IPSPOT_VERSION = "0.4"
 
 IPSPOT_OVERVIEW = '''
 IPSpot is a Python library for retrieving the current system's IP address and location information.
@@ -22,11 +22,19 @@ class IPv4API(Enum):
     """Public IPv4 API enum."""
 
     AUTO = "auto"
-    IPAPI = "ipapi"
-    IPINFO = "ipinfo"
-    IPSB = "ipsb"
-    IDENTME = "identme"
-    TNEDIME = "tnedime"
+    AUTO_SAFE = "auto-safe"
+    IP_API_COM = "ip-api.com"
+    IPAPI_CO = "ipapi.co"
+    IPINFO_IO = "ipinfo.io"
+    IP_SB = "ip.sb"
+    IDENT_ME = "ident.me"
+    TNEDI_ME = "tnedi.me"
+    IPLEAK_NET = "ipleak.net"
+    MY_IP_IO = "my-ip.io"
+    IFCONFIG_CO = "ifconfig.co"
+    REALLYFREEGEOIP_ORG = "reallyfreegeoip.org"
+    MYIP_LA = "myip.la"
+    FREEIPAPI_COM = "freeipapi.com"
 
 
 PARAMETERS_NAME_MAP = {

ipspot/utils.py

@@ -1,7 +1,33 @@
 # -*- coding: utf-8 -*-
 """ipspot utils."""
+import time
 import ipaddress
-from typing import Any
+import requests
+from typing import Callable, Dict
+from typing import Union, Tuple, Any
+from .params import REQUEST_HEADERS
+
+
+def _attempt_with_retries(
+        func: Callable,
+        max_retries: int,
+        retry_delay: float, **kwargs: dict) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+    """
+    Attempt a function call with retries and delay.
+
+    :param func: function to execute
+    :param max_retries: number of retries
+    :param retry_delay: delay between retries (in seconds)
+    :param kwargs: keyword arguments to pass to the function
+    """
+    max_retries = max(0, max_retries)
+    result = {"status": False, "error": ""}
+    for attempt in range(max_retries + 1):
+        result = func(**kwargs)
+        if result["status"]:
+            break
+        time.sleep(retry_delay)
+    return result
 
 
 def is_loopback(ip: str) -> bool:
@@ -17,7 +43,7 @@ def is_loopback(ip: str) -> bool:
         return False
 
 
-def filter_parameter(parameter: Any) -> Any:
+def _filter_parameter(parameter: Any) -> Any:
     """
     Filter input parameter.
 
@@ -28,3 +54,16 @@ def filter_parameter(parameter: Any) -> Any:
     if isinstance(parameter, str) and len(parameter.strip()) == 0:
         return "N/A"
     return parameter
+
+
+def _get_json_standard(url: str, timeout: Union[float, Tuple[float, float]]) -> dict:
+    """
+    Send standard GET request that returns JSON response.
+
+    :param url: API url
+    :param timeout: timeout value for API
+    """
+    with requests.Session() as session:
+        response = session.get(url, headers=REQUEST_HEADERS, timeout=timeout)
+        response.raise_for_status()
+        return response.json()

{ipspot-0.3.dist-info → ipspot-0.4.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ipspot
-Version: 0.3
+Version: 0.4
 Summary: IPSpot: A Python Tool to Fetch the System's IP Address
 Home-page: https://github.com/openscilab/ipspot
-Download-URL: https://github.com/openscilab/ipspot/tarball/v0.3
+Download-URL: https://github.com/openscilab/ipspot/tarball/v0.4
 Author: IPSpot Development Team
 Author-email: ipspot@openscilab.com
 License: MIT
@@ -102,13 +102,13 @@ Dynamic: summary
 ## Installation		
 
 ### Source Code
-- Download [Version 0.3](https://github.com/openscilab/ipspot/archive/v0.3.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
+- Download [Version 0.4](https://github.com/openscilab/ipspot/archive/v0.4.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
 - `pip install .`				
 
 ### PyPI
 
 - Check [Python Packaging User Guide](https://packaging.python.org/installing/)     
-- `pip install ipspot==0.3`						
+- `pip install ipspot==0.4`						
 
 
 ## Usage
@@ -119,9 +119,11 @@ Dynamic: summary
 
 ```pycon
 >>> from ipspot import get_public_ipv4, IPv4API
->>> get_public_ipv4(api=IPv4API.IPAPI)
+>>> get_public_ipv4(api=IPv4API.IP_API_COM)
 {'status': True, 'data': {'ip': 'xx.xx.xx.xx', 'api': 'ip-api.com'}}
->>> get_public_ipv4(api=IPv4API.IPAPI, geo=True, timeout=10)
+>>> get_public_ipv4(api=IPv4API.IP_API_COM, geo=True, timeout=10)
+{'data': {'country_code': 'GB', 'latitude': 50.9097, 'longitude': -1.4043, 'api': 'ip-api.com', 'country': 'United Kingdom', 'timezone': 'Europe/London', 'organization': '', 'region': 'England', 'ip': 'xx.xx.xx.xx', 'city': 'Southampton'}, 'status': True}
+>>> get_public_ipv4(api=IPv4API.IP_API_COM, geo=True, timeout=10, max_retries=5, retry_delay=4)
 {'data': {'country_code': 'GB', 'latitude': 50.9097, 'longitude': -1.4043, 'api': 'ip-api.com', 'country': 'United Kingdom', 'timezone': 'Europe/London', 'organization': '', 'region': 'England', 'ip': 'xx.xx.xx.xx', 'city': 'Southampton'}, 'status': True}
 ```
 
@@ -142,7 +144,7 @@ Dynamic: summary
 ```console
 > ipspot --version
 
-0.3
+0.4
 ```
 
 #### Info
@@ -157,11 +159,11 @@ Dynamic: summary
 |___||_|    |____/ | .__/  \___/  \__|
                    |_|
 
-__     __     ___      _____
-\ \   / / _  / _ \    |___ /
- \ \ / / (_)| | | |     |_ \
-  \ V /   _ | |_| | _  ___) |
-   \_/   (_) \___/ (_)|____/
+__     __     ___      _  _
+\ \   / / _  / _ \    | || |
+ \ \ / / (_)| | | |   | || |_
+  \ V /   _ | |_| | _ |__   _|
+   \_/   (_) \___/ (_)   |_|
 
 
 
@@ -197,12 +199,12 @@ Public IP and Location Info:
 
 #### IPv4 API
 
-ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`, `identme`, `tnedime`]
+ℹ️ `ipv4-api` valid choices: [`auto-safe`, `auto`, `ip-api.com`, `ipinfo.io`, `ip.sb`, `ident.me`, `tnedi.me`, `ipapi.co`, `ipleak.net`, `my-ip.io`, `ifconfig.co`, `reallyfreegeoip.org`, `freeipapi.com`, `myip.la`]
 
-ℹ️ The default value: `auto`
+ℹ️ The default value: `auto-safe`
 
 ```console
-> ipspot --ipv4-api="ipinfo"
+> ipspot --ipv4-api="ipinfo.io"
 Private IP:
 
   10.36.18.154
@@ -267,6 +269,29 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [0.4] - 2025-06-09
+### Added
+- Support [ipapi.co](https://ipapi.co/json/)
+- Support [ipleak.net](https://ipleak.net/json/)
+- Support [my-ip.io](https://www.my-ip.io/)
+- Support [ifconfig.co](https://ifconfig.co/json)
+- Support [reallyfreegeoip.org](https://reallyfreegeoip.org/json/)
+- Support [myip.la](https://api.myip.la/en?json)
+- Support [freeipapi.com](https://freeipapi.com/api/json/)
+- `AUTO_SAFE` mode
+- `_get_json_standard` function
+- `_get_json_ipv4_forced` function
+- `--max-retries` argument
+- `--retry-delay` argument
+### Changed
+- `IPv4API.IPAPI` renamed to `IPv4API.IP_API_COM`
+- `IPv4API.IPINFO` renamed to `IPv4API.IPINFO_IO`
+- `IPv4API.IPSB` renamed to `IPv4API.IP_SB`
+- `IPv4API.IDENTME` renamed to `IPv4API.IDENT_ME`
+- `IPv4API.TNEDIME` renamed to `IPv4API.TNEDI_ME`
+- `get_public_ipv4` function modified
+- `filter_parameter` function renamed to `_filter_parameter`
+- `README.md` updated
 ## [0.3] - 2025-05-19
 ### Added
 - `is_ipv4` function
@@ -303,7 +328,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - `--no-geo` argument
 - Logo
 
-[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.3...dev
+[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.4...dev
+[0.4]: https://github.com/openscilab/ipspot/compare/v0.3...v0.4
 [0.3]: https://github.com/openscilab/ipspot/compare/v0.2...v0.3
 [0.2]: https://github.com/openscilab/ipspot/compare/v0.1...v0.2
 [0.1]: https://github.com/openscilab/ipspot/compare/3216fb7...v0.1

ipspot-0.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+ipspot/__init__.py,sha256=e_1FqqNDD9eoDVw9eKL_1pS7du-Sei3lm6A4UFjYiUo,211
+ipspot/__main__.py,sha256=xKHY_tc94SWktkIHV0O9YADAHPZvT8yXOFSm_L2yMno,105
+ipspot/cli.py,sha256=M23l9ftqKbdDGhb906q4ywJmcjkHW3VWijyXj76APC4,3222
+ipspot/ipv4.py,sha256=zGFvzD2GeM2lFxMWc6lcCphBaj5qY0kxiHE0FBhDoTc,19998
+ipspot/params.py,sha256=hdArSL10EEq4vtfxA51ftCkn5WfsAzsxdoX1T11yCdQ,1419
+ipspot/utils.py,sha256=YtkyWGljpFc72rSGljsARjlVrF9hkE7Gl78_5uex1yI,1870
+ipspot-0.4.dist-info/licenses/AUTHORS.md,sha256=5ZvxP1KnuVkurB4psQDSqnqiAyn44q1aeiXUsnYgps4,411
+ipspot-0.4.dist-info/licenses/LICENSE,sha256=0aOd4wzZRoSH_35UZXRHS7alPFTtuFEBJrajLuonEIw,1067
+ipspot-0.4.dist-info/METADATA,sha256=8D5MqjjxrCDU60BDPikNoX75iE5bMKVMQX_kFw03WiU,10875
+ipspot-0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ipspot-0.4.dist-info/entry_points.txt,sha256=DJVLepYr8H3UcvWekU5Jy-tcr_xmWrphzgWGNOd3hlk,43
+ipspot-0.4.dist-info/top_level.txt,sha256=v0WgE1z2iCy_bXU53fVcllwHLTvGNBIvq8u3KPC2_Sc,7
+ipspot-0.4.dist-info/RECORD,,

{ipspot-0.3.dist-info → ipspot-0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{ipspot-0.3.dist-info → ipspot-0.4.dist-info}/licenses/AUTHORS.md

@@ -1,6 +1,8 @@
 # Core Developers
 ----------
 - Sepand Haghighi - Open Science Laboratory ([Github](https://github.com/sepandhaghighi)) **
+- Sadra Sabouri - Open Science Laboratory ([Github](https://github.com/sadrasabouri))
+- AmirHosein Rostami  - Open Science Laboratory ([Github](https://github.com/AHReccese))
 
 ** **Maintainer**
 

ipspot-0.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-ipspot/__init__.py,sha256=e_1FqqNDD9eoDVw9eKL_1pS7du-Sei3lm6A4UFjYiUo,211
-ipspot/__main__.py,sha256=xKHY_tc94SWktkIHV0O9YADAHPZvT8yXOFSm_L2yMno,105
-ipspot/cli.py,sha256=Yq0GVzyZhMUauTMA_BUO8UXa6OqfYDBLLVjERZ3vOgE,2632
-ipspot/ipv4.py,sha256=OhQQnRdkwQ-SrfaqJdhF1Qu_zsW-mi93NEk_N5QAOrk,10757
-ipspot/params.py,sha256=EekA1HmFlxRT-wk0mEKHvPSR_O6UTHWSBgQoiC5-aRU,1147
-ipspot/utils.py,sha256=OaRrNQI8ASUHisMVEhyfy4lwcgugRxXK4JcWqljITfE,636
-ipspot-0.3.dist-info/licenses/AUTHORS.md,sha256=AgFL2paPd70ItL_YK18lWm_NjNWytKZHmR57o-et8kU,236
-ipspot-0.3.dist-info/licenses/LICENSE,sha256=0aOd4wzZRoSH_35UZXRHS7alPFTtuFEBJrajLuonEIw,1067
-ipspot-0.3.dist-info/METADATA,sha256=h2XSvM65GkEAL8COdzOpbuOtiQSj3fEgdYCfON6ZCeA,9400
-ipspot-0.3.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-ipspot-0.3.dist-info/entry_points.txt,sha256=DJVLepYr8H3UcvWekU5Jy-tcr_xmWrphzgWGNOd3hlk,43
-ipspot-0.3.dist-info/top_level.txt,sha256=v0WgE1z2iCy_bXU53fVcllwHLTvGNBIvq8u3KPC2_Sc,7
-ipspot-0.3.dist-info/RECORD,,