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

ipspot/cli.py

@@ -8,9 +8,11 @@ from .ipv6 import get_public_ipv6, get_private_ipv6
 from .utils import _filter_parameter
 from .params import IPv4API, IPv6API, PARAMETERS_NAME_MAP
 from .params import IPSPOT_OVERVIEW, IPSPOT_REPO, IPSPOT_VERSION
+from .params import PUBLIC_IPV4_ERROR, PRIVATE_IPV4_ERROR
+from .params import PUBLIC_IPV6_ERROR, PRIVATE_IPV6_ERROR
 
 
-def ipspot_info() -> None:  # pragma: no cover
+def _print_ipspot_info() -> None:  # pragma: no cover
     """Print ipspot details."""
     tprint("IPSpot")
     tprint("V:" + IPSPOT_VERSION)
@@ -18,11 +20,13 @@ def ipspot_info() -> None:  # pragma: no cover
     print("Repo : " + IPSPOT_REPO)
 
 
-def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO_SAFE,
-                    ipv6_api: IPv6API = IPv6API.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
+def _print_report(ipv4_api: IPv4API,
+                  ipv6_api: IPv6API,
+                  geo: bool,
+                  timeout: Union[float, Tuple[float, float]],
+                  max_retries: int,
+                  retry_delay: float,
+                  backoff_factor: float) -> None:  # pragma: no cover
     """
     Print collected IP and location data.
 
@@ -32,20 +36,21 @@ def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO_SAFE,
     :param timeout: timeout value for API
     :param max_retries: number of retries
     :param retry_delay: delay between retries (in seconds)
+    :param backoff_factor: backoff factor
     """
     print("Private IP:\n")
     private_ipv4_result = get_private_ipv4()
     if private_ipv4_result["status"]:
         private_ipv4 = private_ipv4_result["data"]["ip"]
     else:
-        private_ipv4 = private_ipv4_result["error"]
+        private_ipv4 = PRIVATE_IPV4_ERROR
     print("  IPv4: {private_ipv4}\n".format(private_ipv4=private_ipv4))
 
     private_ipv6_result = get_private_ipv6()
     if private_ipv6_result["status"]:
         private_ipv6 = private_ipv6_result["data"]["ip"]
     else:
-        private_ipv6 = private_ipv6_result["error"]
+        private_ipv6 = PRIVATE_IPV6_ERROR
     print("  IPv6: {private_ipv6}".format(private_ipv6=private_ipv6))
 
     public_title = "\nPublic IP"
@@ -59,7 +64,8 @@ def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO_SAFE,
         geo=geo,
         timeout=timeout,
         max_retries=max_retries,
-        retry_delay=retry_delay)
+        retry_delay=retry_delay,
+        backoff_factor=backoff_factor)
     if public_ipv4_result["status"]:
         for name, parameter in sorted(public_ipv4_result["data"].items()):
             print(
@@ -67,7 +73,7 @@ def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO_SAFE,
                     name=PARAMETERS_NAME_MAP[name],
                     parameter=_filter_parameter(parameter)))
     else:
-        print("    Error: {public_ipv4_result[error]}".format(public_ipv4_result=public_ipv4_result))
+        print("    Error: {public_ipv4_result}".format(public_ipv4_result=PUBLIC_IPV4_ERROR))
 
     print("\n  IPv6:\n")
     public_ipv6_result = get_public_ipv6(
@@ -75,7 +81,8 @@ def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO_SAFE,
         geo=geo,
         timeout=timeout,
         max_retries=max_retries,
-        retry_delay=retry_delay)
+        retry_delay=retry_delay,
+        backoff_factor=backoff_factor)
     if public_ipv6_result["status"]:
         for name, parameter in sorted(public_ipv6_result["data"].items()):
             print(
@@ -83,7 +90,7 @@ def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO_SAFE,
                     name=PARAMETERS_NAME_MAP[name],
                     parameter=_filter_parameter(parameter)))
     else:
-        print("    Error: {public_ipv6_result[error]}".format(public_ipv6_result=public_ipv6_result))
+        print("    Error: {public_ipv6_result}".format(public_ipv6_result=PUBLIC_IPV6_ERROR))
 
 
 def main() -> None:  # pragma: no cover
@@ -109,20 +116,22 @@ def main() -> None:  # pragma: no cover
     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)
+    parser.add_argument('--backoff-factor', help='backoff factor', type=float, default=1.0)
 
     args = parser.parse_args()
     if args.version:
         print(IPSPOT_VERSION)
     elif args.info:
-        ipspot_info()
+        _print_ipspot_info()
     else:
         ipv4_api = IPv4API(args.ipv4_api)
         ipv6_api = IPv6API(args.ipv6_api)
         geo = not args.no_geo
-        display_ip_info(
+        _print_report(
             ipv4_api=ipv4_api,
             ipv6_api=ipv6_api,
             geo=geo,
             timeout=args.timeout,
             max_retries=args.max_retries,
-            retry_delay=args.retry_delay)
+            retry_delay=args.retry_delay,
+            backoff_factor=args.backoff_factor)

ipspot/ipv4.py

@@ -3,69 +3,9 @@
 import ipaddress
 import socket
 from typing import Union, Dict, List, Tuple
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.poolmanager import PoolManager
-from .utils import is_loopback, _get_json_standard, _attempt_with_retries
-from .params import REQUEST_HEADERS, IPv4API
-
-
-class IPv4HTTPAdapter(HTTPAdapter):
-    """A custom HTTPAdapter that enforces the use of IPv4 for DNS resolution during HTTP(S) requests using the requests library."""
-
-    def init_poolmanager(self, connections: int, maxsize: int, block: bool = False, **kwargs: dict) -> None:
-        """
-        Initialize the connection pool manager using a temporary override of socket.getaddrinfo to ensure only IPv4 addresses are used.
-
-        :param connections: the number of connection pools to cache
-        :param maxsize: the maximum number of connections to save in the pool
-        :param block: whether the connections should block when reaching the max size
-        :param kwargs: additional keyword arguments for the PoolManager
-        """
-        self.poolmanager = PoolManager(
-            num_pools=connections,
-            maxsize=maxsize,
-            block=block,
-            socket_options=self._ipv4_socket_options(),
-            **kwargs
-        )
-
-    def _ipv4_socket_options(self) -> list:
-        """
-        Temporarily patches socket.getaddrinfo to filter only IPv4 addresses (AF_INET).
-
-        :return: an empty list of socket options; DNS patching occurs here
-        """
-        original_getaddrinfo = socket.getaddrinfo
-
-        def ipv4_only_getaddrinfo(*args: list, **kwargs: dict) -> List[Tuple]:
-            results = original_getaddrinfo(*args, **kwargs)
-            return [res for res in results if res[0] == socket.AF_INET]
-
-        self._original_getaddrinfo = socket.getaddrinfo
-        socket.getaddrinfo = ipv4_only_getaddrinfo
-
-        return []
-
-    def __del__(self) -> None:
-        """Restores the original socket.getaddrinfo function upon adapter deletion."""
-        if hasattr(self, "_original_getaddrinfo"):
-            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()
+from .utils import is_loopback, _attempt_with_retries
+from .utils import _get_json_standard, _get_json_force_ip
+from .params import IPv4API
 
 
 def is_ipv4(ip: str) -> bool:
@@ -96,8 +36,8 @@ def get_private_ipv4() -> Dict[str, Union[bool, Dict[str, str], str]]:
         return {"status": False, "error": str(e)}
 
 
-def _ip_sb_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, timeout: Union[float, Tuple[float, float]]
+                ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ip.sb.
 
@@ -124,8 +64,8 @@ def _ip_sb_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _ipleak_net_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, timeout: Union[float, Tuple[float, float]]
+                     ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipleak.net.
 
@@ -152,8 +92,8 @@ def _ipleak_net_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         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]]:
+def _my_ip_io_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using my-ip.io.
 
@@ -180,8 +120,9 @@ def _my_ip_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         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]]:
+# very low rate limit
+def _ifconfig_co_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
+                      ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ifconfig.co.
 
@@ -189,7 +130,7 @@ def _ifconfig_co_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://ifconfig.co/json", timeout=timeout)
+        data = _get_json_force_ip(url="https://ifconfig.co/json", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "ifconfig.co"}}
         if geo:
             geo_data = {
@@ -208,8 +149,8 @@ def _ifconfig_co_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]
         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]]:
+def _ipapi_co_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipapi.co.
 
@@ -217,7 +158,7 @@ def _ipapi_co_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://ipapi.co/json/", timeout=timeout)
+        data = _get_json_force_ip(url="https://ipapi.co/json/", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "ipapi.co"}}
         if geo:
             geo_data = {
@@ -236,8 +177,8 @@ def _ipapi_co_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         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]]:
+def _ip_api_com_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
+                     ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ip-api.com.
 
@@ -245,7 +186,7 @@ def _ip_api_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="http://ip-api.com/json/", timeout=timeout)
+        data = _get_json_force_ip(url="http://ip-api.com/json/", timeout=timeout, version="ipv4")
         if data.get("status") != "success":
             return {"status": False, "error": "ip-api lookup failed"}
         result = {"status": True, "data": {"ip": data["query"], "api": "ip-api.com"}}
@@ -266,8 +207,8 @@ def _ip_api_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _ipinfo_io_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, timeout: Union[float, Tuple[float, float]]
+                    ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipinfo.io.
 
@@ -275,7 +216,7 @@ def _ipinfo_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://ipinfo.io/json", timeout=timeout)
+        data = _get_json_force_ip(url="https://ipinfo.io/json", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "ipinfo.io"}}
         if geo:
             loc = data.get("loc", "").split(",")
@@ -295,8 +236,8 @@ def _ipinfo_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         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]]:
+def _reallyfreegeoip_org_ipv4(
+        geo: bool, timeout: Union[float, Tuple[float, float]]) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using reallyfreegeoip.org.
 
@@ -304,7 +245,7 @@ def _reallyfreegeoip_org_ipv4(geo: bool=False, timeout: Union[float, Tuple[float
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://reallyfreegeoip.org/json/", timeout=timeout)
+        data = _get_json_force_ip(url="https://reallyfreegeoip.org/json/", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "reallyfreegeoip.org"}}
         if geo:
             geo_data = {
@@ -323,8 +264,8 @@ def _reallyfreegeoip_org_ipv4(geo: bool=False, timeout: Union[float, Tuple[float
         return {"status": False, "error": str(e)}
 
 
-def _ident_me_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ident_me_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ident.me.
 
@@ -351,8 +292,8 @@ def _ident_me_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _tnedi_me_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, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using tnedi.me.
 
@@ -379,7 +320,7 @@ def _tnedi_me_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _myip_la_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+def _myip_la_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using myip.la.
@@ -388,7 +329,7 @@ def _myip_la_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://api.myip.la/en?json", timeout=timeout)
+        data = _get_json_force_ip(url="https://api.myip.la/en?json", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "myip.la"}}
         if geo:
             loc = data.get("location", {})
@@ -408,7 +349,7 @@ def _myip_la_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
         return {"status": False, "error": str(e)}
 
 
-def _freeipapi_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+def _freeipapi_com_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
                         ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using freeipapi.com.
@@ -417,8 +358,9 @@ def _freeipapi_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, floa
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://freeipapi.com/api/json", timeout=timeout)
+        data = _get_json_force_ip(url="https://freeipapi.com/api/json", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ipAddress"], "api": "freeipapi.com"}}
+        tzs = data.get("timeZones", [])
         if geo:
             geo_data = {
                 "city": data.get("cityName"),
@@ -427,8 +369,8 @@ def _freeipapi_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, floa
                 "country_code": data.get("countryCode"),
                 "latitude": data.get("latitude"),
                 "longitude": data.get("longitude"),
-                "organization": None,
-                "timezone": data.get("timeZone")
+                "organization": data.get("asnOrganization"),
+                "timezone": tzs[0] if len(tzs) > 0 else None
             }
             result["data"].update(geo_data)
         return result
@@ -436,7 +378,7 @@ def _freeipapi_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, floa
         return {"status": False, "error": str(e)}
 
 
-def _ipquery_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+def _ipquery_io_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
                      ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipquery.io.
@@ -445,7 +387,7 @@ def _ipquery_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://api.ipquery.io/?format=json", timeout=timeout)
+        data = _get_json_force_ip(url="https://api.ipquery.io/?format=json", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "ipquery.io"}}
         if geo:
             loc = data.get("location", {})
@@ -466,7 +408,7 @@ def _ipquery_io_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _ipwho_is_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+def _ipwho_is_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
                    ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipwho.is.
@@ -475,7 +417,7 @@ def _ipwho_is_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
     :param timeout: timeout value for API
     """
     try:
-        data = _get_json_ipv4_forced(url="https://ipwho.is", timeout=timeout)
+        data = _get_json_force_ip(url="https://ipwho.is", timeout=timeout, version="ipv4")
         result = {"status": True, "data": {"ip": data["ip"], "api": "ipwho.is"}}
         if geo:
             connection = data.get("connection", {})
@@ -496,7 +438,7 @@ def _ipwho_is_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
         return {"status": False, "error": str(e)}
 
 
-def _wtfismyip_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, float]]=5
+def _wtfismyip_com_ipv4(geo: bool, timeout: Union[float, Tuple[float, float]]
                         ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using wtfismyip.com.
@@ -606,7 +548,8 @@ IPV4_API_MAP = {
 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]]:
+                    retry_delay: float = 1.0,
+                    backoff_factor: float = 1.0) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IPv4 and geolocation info based on the selected API.
 
@@ -615,6 +558,7 @@ def get_public_ipv4(api: IPv4API=IPv4API.AUTO_SAFE, geo: bool=False,
     :param timeout: timeout value for API
     :param max_retries: number of retries
     :param retry_delay: delay between retries (in seconds)
+    :param backoff_factor: backoff factor
     """
     if api in [IPv4API.AUTO, IPv4API.AUTO_SAFE]:
         for _, api_data in IPV4_API_MAP.items():
@@ -625,6 +569,7 @@ def get_public_ipv4(api: IPv4API=IPv4API.AUTO_SAFE, geo: bool=False,
                 func=func,
                 max_retries=max_retries,
                 retry_delay=retry_delay,
+                backoff_factor=backoff_factor,
                 geo=geo,
                 timeout=timeout)
             if result["status"]:
@@ -638,6 +583,7 @@ def get_public_ipv4(api: IPv4API=IPv4API.AUTO_SAFE, geo: bool=False,
                 func=func,
                 max_retries=max_retries,
                 retry_delay=retry_delay,
+                backoff_factor=backoff_factor,
                 geo=geo,
                 timeout=timeout)
         return {"status": False, "error": "Unsupported API: {api}".format(api=api)}

ipspot/ipv6.py

@@ -4,7 +4,8 @@ import ipaddress
 import socket
 from typing import Union, Dict, List, Tuple
 from .params import IPv6API
-from .utils import is_loopback, _get_json_standard, _attempt_with_retries
+from .utils import is_loopback, _attempt_with_retries
+from .utils import _get_json_standard, _get_json_force_ip
 
 
 def is_ipv6(ip: str) -> bool:
@@ -36,8 +37,8 @@ def get_private_ipv6() -> Dict[str, Union[bool, Dict[str, str], str]]:
         return {"status": False, "error": str(e)}
 
 
-def _ip_sb_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ip_sb_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ip.sb.
 
@@ -64,8 +65,8 @@ def _ip_sb_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _ident_me_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ident_me_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ident.me.
 
@@ -92,8 +93,8 @@ def _ident_me_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _tnedi_me_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _tnedi_me_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using tnedi.me.
 
@@ -120,8 +121,8 @@ def _tnedi_me_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _ipleak_net_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                     =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _ipleak_net_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                     ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using ipleak.net.
 
@@ -148,8 +149,8 @@ def _ipleak_net_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _my_ip_io_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                   =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+def _my_ip_io_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                   ) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IP and geolocation using my-ip.io.
 
@@ -176,6 +177,121 @@ def _my_ip_io_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
+# very low rate limit
+def _ifconfig_co_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                      ) -> 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_force_ip(url="https://ifconfig.co/json", timeout=timeout, version="ipv6")
+        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 _reallyfreegeoip_org_ipv6(
+        geo: bool, timeout: Union[float, Tuple[float, float]]) -> 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_force_ip(url="https://reallyfreegeoip.org/json/", timeout=timeout, version="ipv6")
+        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)}
+
+
+def _myip_la_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                  ) -> 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_force_ip(url="https://api.myip.la/en?json", timeout=timeout, version="ipv6")
+        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_ipv6(geo: bool, timeout: Union[float, Tuple[float, float]]
+                        ) -> 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_force_ip(url="https://free.freeipapi.com/api/json", timeout=timeout, version="ipv6")
+        result = {"status": True, "data": {"ip": data["ipAddress"], "api": "freeipapi.com"}}
+        tzs = data.get("timeZones", [])
+        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": data.get("asnOrganization"),
+                "timezone": tzs[0] if len(tzs) > 0 else None
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
 IPV6_API_MAP = {
     IPv6API.IP_SB: {
         "thread_safe": True,
@@ -202,13 +318,34 @@ IPV6_API_MAP = {
         "geo": True,
         "function": _my_ip_io_ipv6
     },
+    IPv6API.IFCONFIG_CO: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _ifconfig_co_ipv6
+    },
+    IPv6API.REALLYFREEGEOIP_ORG: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _reallyfreegeoip_org_ipv6
+    },
+    IPv6API.MYIP_LA: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _myip_la_ipv6
+    },
+    IPv6API.FREEIPAPI_COM: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _freeipapi_com_ipv6
+    }
 }
 
 
 def get_public_ipv6(api: IPv6API=IPv6API.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]]:
+                    retry_delay: float = 1.0,
+                    backoff_factor: float = 1.0) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
     """
     Get public IPv6 and geolocation info based on the selected API.
 
@@ -217,6 +354,7 @@ def get_public_ipv6(api: IPv6API=IPv6API.AUTO_SAFE, geo: bool=False,
     :param timeout: timeout value for API
     :param max_retries: number of retries
     :param retry_delay: delay between retries (in seconds)
+    :param backoff_factor: backoff factor
     """
     if api in [IPv6API.AUTO, IPv6API.AUTO_SAFE]:
         for _, api_data in IPV6_API_MAP.items():
@@ -227,6 +365,7 @@ def get_public_ipv6(api: IPv6API=IPv6API.AUTO_SAFE, geo: bool=False,
                 func=func,
                 max_retries=max_retries,
                 retry_delay=retry_delay,
+                backoff_factor=backoff_factor,
                 geo=geo,
                 timeout=timeout)
             if result["status"]:
@@ -240,6 +379,7 @@ def get_public_ipv6(api: IPv6API=IPv6API.AUTO_SAFE, geo: bool=False,
                 func=func,
                 max_retries=max_retries,
                 retry_delay=retry_delay,
+                backoff_factor=backoff_factor,
                 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.5"
+IPSPOT_VERSION = "0.7"
 
 IPSPOT_OVERVIEW = '''
 IPSpot is a Python library for retrieving the current system's IP address and location information.
@@ -50,6 +50,10 @@ class IPv6API(Enum):
     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 = {
@@ -64,3 +68,8 @@ PARAMETERS_NAME_MAP = {
     "organization": "Organization",
     "api": "API"
 }
+
+PUBLIC_IPV4_ERROR = "Unable to retrieve public IPv4 information."
+PRIVATE_IPV4_ERROR = "Unable to retrieve private IPv4 address."
+PUBLIC_IPV6_ERROR = "Unable to retrieve public IPv6 information."
+PRIVATE_IPV6_ERROR = "Unable to retrieve private IPv6 address."

ipspot/utils.py

@@ -2,31 +2,99 @@
 """ipspot utils."""
 import time
 import ipaddress
+import socket
 import requests
+from requests.adapters import HTTPAdapter
 from typing import Callable, Dict
-from typing import Union, Tuple, Any
+from typing import Union, Tuple, Any, List
 from .params import REQUEST_HEADERS
 
 
+class ForceIPHTTPAdapter(HTTPAdapter):
+    """A custom HTTPAdapter that enforces IPv4 or IPv6 DNS resolution for HTTP(S) requests."""
+
+    def __init__(self, version: str = "ipv4", *args: list, **kwargs: dict) -> None:
+        """
+        Initialize the adapter with the desired IP version.
+
+        :param version: 'ipv4' or 'ipv6' to select address family
+        :param args: additional list arguments for the HTTPAdapter
+        :param kwargs: additional keyword arguments for the HTTPAdapter
+        """
+        self.version = version.lower()
+        if self.version not in ("ipv4", "ipv6"):
+            raise ValueError("version must be either 'ipv4' or 'ipv6'")
+        super().__init__(*args, **kwargs)
+
+    def send(self, *args: list, **kwargs: dict) -> Any:
+        """
+        Override send method to apply the monkey patch only during the request.
+
+        :param args: additional list arguments for the send method
+        :param kwargs: additional keyword arguments for the send method
+        """
+        family = socket.AF_INET if self.version == "ipv4" else socket.AF_INET6
+        original_getaddrinfo = socket.getaddrinfo
+
+        def filtered_getaddrinfo(*gargs: list, **gkwargs: dict) -> List[Tuple]:
+            """
+            Filter getaddrinfo.
+
+            :param gargs: additional list arguments for the original_getaddrinfo function
+            :param gkwargs: additional keyword arguments for the original_getaddrinfo function
+            """
+            results = original_getaddrinfo(*gargs, **gkwargs)
+            return [res for res in results if res[0] == family]
+
+        socket.getaddrinfo = filtered_getaddrinfo
+        try:
+            response = super().send(*args, **kwargs)
+        finally:
+            socket.getaddrinfo = original_getaddrinfo
+        return response
+
+
+def _get_json_force_ip(url: str, timeout: Union[float, Tuple[float, float]],
+                       version: str = "ipv4") -> dict:
+    """
+    Send GET request with forced IPv4/IPv6 using ForceIPHTTPAdapter that returns JSON response.
+
+    :param url: API url
+    :param timeout: timeout value for API
+    :param version: 'ipv4' or 'ipv6' to select address family
+    """
+    with requests.Session() as session:
+        session.mount("http://", ForceIPHTTPAdapter(version=version))
+        session.mount("https://", ForceIPHTTPAdapter(version=version))
+        response = session.get(url, headers=REQUEST_HEADERS, timeout=timeout)
+        response.raise_for_status()
+        return response.json()
+
+
 def _attempt_with_retries(
         func: Callable,
         max_retries: int,
-        retry_delay: float, **kwargs: dict) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+        retry_delay: float,
+        backoff_factor: 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 backoff_factor: backoff factor
     :param kwargs: keyword arguments to pass to the function
     """
     max_retries = max(0, max_retries)
     result = {"status": False, "error": ""}
+    next_delay = retry_delay
     for attempt in range(max_retries + 1):
         result = func(**kwargs)
         if result["status"]:
             break
-        time.sleep(retry_delay)
+        time.sleep(next_delay)
+        next_delay *= backoff_factor
     return result
 
 

{ipspot-0.5.dist-info → ipspot-0.7.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: ipspot
-Version: 0.5
+Version: 0.7
 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.5
+Download-URL: https://github.com/openscilab/ipspot/tarball/v0.7
 Author: IPSpot Development Team
 Author-email: ipspot@openscilab.com
 License: MIT
 Project-URL: Source, https://github.com/openscilab/ipspot
 Keywords: ip ipv4 geo geolocation network location ipspot cli
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Natural Language :: English
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: End Users/Desktop
@@ -52,6 +53,7 @@ Dynamic: summary
 <img src="https://github.com/openscilab/ipspot/raw/main/otherfiles/logo.png" width="350">
 <h1>IPSpot: A Python Tool to Fetch the System's IP Address</h1>
 <br/>
+<a href="https://codecov.io/gh/openscilab/ipspot"><img src="https://codecov.io/gh/openscilab/ipspot/graph/badge.svg?token=XCFKASULS8"></a>
 <a href="https://badge.fury.io/py/ipspot"><img src="https://badge.fury.io/py/ipspot.svg" alt="PyPI version"></a>
 <a href="https://www.python.org/"><img src="https://img.shields.io/badge/built%20with-Python3-green.svg" alt="built with Python3"></a>
 <a href="https://github.com/openscilab/ipspot"><img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/openscilab/ipspot"></a>
@@ -102,13 +104,13 @@ Dynamic: summary
 ## Installation		
 
 ### Source Code
-- Download [Version 0.5](https://github.com/openscilab/ipspot/archive/v0.5.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
+- Download [Version 0.7](https://github.com/openscilab/ipspot/archive/v0.7.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.5`						
+- `pip install ipspot==0.7`						
 
 
 ## Usage
@@ -123,7 +125,7 @@ Dynamic: summary
 {'status': True, 'data': {'ip': 'xx.xx.xx.xx', 'api': 'ip-api.com'}}
 >>> 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)
+>>> get_public_ipv4(api=IPv4API.IP_API_COM, geo=True, timeout=10, max_retries=5, retry_delay=4, backoff_factor=1.2)
 {'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}
 ```
 
@@ -143,7 +145,7 @@ Dynamic: summary
 {'data': {'api': 'ip.sb', 'ip': 'xx:xx:xx:xx::xx'}, 'status': True}
 >>> get_public_ipv6(api=IPv6API.IP_SB, geo=True, timeout=10)
 {'data': {'latitude': 51.2993, 'region': None, 'city': None, 'country_code': 'DE', 'api': 'ip.sb', 'longitude': 9.491, 'country': 'Germany', 'organization': 'Hetzner Online', 'timezone': 'Europe/Berlin', 'ip': 'xx:xx:xx:xx::xx'}, 'status': True}
->>> get_public_ipv6(api=IPv6API.IP_SB, geo=True, timeout=10, max_retries=5, retry_delay=4)
+>>> get_public_ipv6(api=IPv6API.IP_SB, geo=True, timeout=10, max_retries=5, retry_delay=4, backoff_factor=1.2)
 {'data': {'latitude': 51.2993, 'region': None, 'city': None, 'country_code': 'DE', 'api': 'ip.sb', 'longitude': 9.491, 'country': 'Germany', 'organization': 'Hetzner Online', 'timezone': 'Europe/Berlin', 'ip': 'xx:xx:xx:xx::xx'}, 'status': True}
 ```
 
@@ -164,7 +166,7 @@ Dynamic: summary
 ```console
 > ipspot --version
 
-0.5
+0.7
 ```
 
 #### Info
@@ -172,18 +174,18 @@ Dynamic: summary
 ```console
 > ipspot --info
 
- ___  ____   ____                 _
-|_ _||  _ \ / ___|  _ __    ___  | |_
+ ___  ____   ____                 _   
+|_ _||  _ \ / ___|  _ __    ___  | |_ 
  | | | |_) |\___ \ | '_ \  / _ \ | __|
- | | |  __/  ___) || |_) || (_) || |_
+ | | |  __/  ___) || |_) || (_) || |_ 
 |___||_|    |____/ | .__/  \___/  \__|
-                   |_|
+                   |_|                
 
-__     __     ___      ____
-\ \   / / _  / _ \    | ___|
- \ \ / / (_)| | | |   |___ \
-  \ V /   _ | |_| | _  ___) |
-   \_/   (_) \___/ (_)|____/
+__     __     ___      _____ 
+\ \   / / _  / _ \    |___  |
+ \ \ / / (_)| | | |      / / 
+  \ V /   _ | |_| | _   / /  
+   \_/   (_) \___/ (_) /_/ 
 
 
 
@@ -207,16 +209,31 @@ Private IP:
 
 Public IP and Location Info:
 
-  API: ip-api.com
-  City: Southampton
-  Country: United Kingdom
-  Country Code: GB
-  IP: xx.xx.xx.xx
-  Latitude: 50.9097
-  Longitude: -1.4043
-  Organization: N/A
-  Region: England
-  Timezone: Europe/London
+  IPv4:
+
+    API: ipinfo.io
+    City: Nuremberg
+    Country: Germany
+    Country Code: DE
+    IP: xx.xx.xx.xx
+    Latitude: 49.4527
+    Longitude: 11.0783
+    Organization: Hetzner Online GmbH
+    Region: Bavaria
+    Timezone: Europe/Berlin
+
+  IPv6:
+
+    API: ip.sb
+    City: N/A
+    Country: Germany
+    Country Code: DE
+    IP: xx:xx:xx:xx::xx
+    Latitude: 51.2993
+    Longitude: 9.491
+    Organization: Hetzner Online
+    Region: N/A
+    Timezone: Europe/Berlin
 ```
 
 #### IPv4 API
@@ -264,7 +281,7 @@ Public IP and Location Info:
 
 #### IPv6 API
 
-ℹ️ `ipv6-api` valid choices: [`auto-safe`, `auto`, `ip.sb`, `ident.me`, `tnedi.me`, `ipleak.net`, `my-ip.io`]
+ℹ️ `ipv6-api` valid choices: [`auto-safe`, `auto`, `ip.sb`, `ident.me`, `tnedi.me`, `ipleak.net`, `my-ip.io`, `ifconfig.co`, `reallyfreegeoip.org`, `myip.la`, `freeipapi.com`]
 
 ℹ️ The default value: `auto-safe`
 
@@ -360,6 +377,31 @@ 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.7] - 2025-12-09
+### Added
+- `--backoff-factor` argument
+### Changed
+- CLI messages updated
+- `Python 3.14` added to `test.yml`
+- Internal functions default values removed
+- `README.md` updated
+- Test system modified
+- `ipspot_info` function renamed to `_print_ipspot_info`
+- `display_ip_info` function renamed to `_print_report`
+## [0.6] - 2025-11-18
+### Added
+- `ForceIPHTTPAdapter` class
+- `_get_json_force_ip` function
+- Support [ifconfig.co](https://ifconfig.co/json) IPv6 API
+- Support [reallyfreegeoip.org](https://reallyfreegeoip.org/json/) IPv6 API
+- Support [myip.la](https://api.myip.la/en?json) IPv6 API
+- Support [freeipapi.com](https://freeipapi.com/api/json) IPv6 API
+### Changed
+- [freeipapi.com](https://freeipapi.com/api/json) IPv4 API bug fixed
+- `README.md` updated
+### Removed
+- `IPv4HTTPAdapter` class
+- `_get_json_ipv4_forced` function
 ## [0.5] - 2025-10-17
 ### Added
 - `setup-warp` action
@@ -438,7 +480,9 @@ 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.5...dev
+[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.7...dev
+[0.7]: https://github.com/openscilab/ipspot/compare/v0.6...v0.7
+[0.6]: https://github.com/openscilab/ipspot/compare/v0.5...v0.6
 [0.5]: https://github.com/openscilab/ipspot/compare/v0.4...v0.5
 [0.4]: https://github.com/openscilab/ipspot/compare/v0.3...v0.4
 [0.3]: https://github.com/openscilab/ipspot/compare/v0.2...v0.3

ipspot-0.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+ipspot/__init__.py,sha256=B47uAOAidLkXps1A4zDig6NN2kB3HcdMC20UOrrEfB4,281
+ipspot/__main__.py,sha256=xKHY_tc94SWktkIHV0O9YADAHPZvT8yXOFSm_L2yMno,105
+ipspot/cli.py,sha256=Y48HA_s6SrTCtjn-iAFNMplAARLwBUx8zpxesG0hARE,4980
+ipspot/ipv4.py,sha256=QGeVZWruziLwe0bxtvo7k0xrnY73-znsXtSsvELYdyE,21613
+ipspot/ipv6.py,sha256=xkgKyTSP_3TTijeM0BftiKL1KlIqMtRucb16-2QrkzA,14081
+ipspot/params.py,sha256=u8eEDVB40Fo52DRhD7-mPg30U62Brtc2aGi9ZhqYuC8,2142
+ipspot/utils.py,sha256=W3HJ61_KVtdg4gWr4m9xXblQc_E30rJoF1aKk36Zqzg,4591
+ipspot-0.7.dist-info/licenses/AUTHORS.md,sha256=5ZvxP1KnuVkurB4psQDSqnqiAyn44q1aeiXUsnYgps4,411
+ipspot-0.7.dist-info/licenses/LICENSE,sha256=0aOd4wzZRoSH_35UZXRHS7alPFTtuFEBJrajLuonEIw,1067
+ipspot-0.7.dist-info/METADATA,sha256=P0uWs_6IZgVWPXJd53rsfvrepgJwLUq7Y8v_FNTDzB0,15395
+ipspot-0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ipspot-0.7.dist-info/entry_points.txt,sha256=DJVLepYr8H3UcvWekU5Jy-tcr_xmWrphzgWGNOd3hlk,43
+ipspot-0.7.dist-info/top_level.txt,sha256=v0WgE1z2iCy_bXU53fVcllwHLTvGNBIvq8u3KPC2_Sc,7
+ipspot-0.7.dist-info/RECORD,,

ipspot-0.5.dist-info/RECORD

@@ -1,14 +0,0 @@
-ipspot/__init__.py,sha256=B47uAOAidLkXps1A4zDig6NN2kB3HcdMC20UOrrEfB4,281
-ipspot/__main__.py,sha256=xKHY_tc94SWktkIHV0O9YADAHPZvT8yXOFSm_L2yMno,105
-ipspot/cli.py,sha256=MdyMh-9miuT8zQgklVrvsimaXnqD17sviWRJbUWlk58,4637
-ipspot/ipv4.py,sha256=-HGv-yAsFI56I06qNFDquVVGP9ZhfWwih1Vs3JtemZQ,23825
-ipspot/ipv6.py,sha256=svGgydUUSoXeuT2hLgi5CDDy3n2PtV-b6uDvP5t_iKI,8754
-ipspot/params.py,sha256=PVnz3F1jB5aIle_fScGoF-0MfREhMxcTCXGEXmimUQs,1741
-ipspot/utils.py,sha256=YtkyWGljpFc72rSGljsARjlVrF9hkE7Gl78_5uex1yI,1870
-ipspot-0.5.dist-info/licenses/AUTHORS.md,sha256=5ZvxP1KnuVkurB4psQDSqnqiAyn44q1aeiXUsnYgps4,411
-ipspot-0.5.dist-info/licenses/LICENSE,sha256=0aOd4wzZRoSH_35UZXRHS7alPFTtuFEBJrajLuonEIw,1067
-ipspot-0.5.dist-info/METADATA,sha256=Sbzs3OQ0QZH22X8bNrcLxWbYb1zKBtKwbPf9AVAEon0,13824
-ipspot-0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ipspot-0.5.dist-info/entry_points.txt,sha256=DJVLepYr8H3UcvWekU5Jy-tcr_xmWrphzgWGNOd3hlk,43
-ipspot-0.5.dist-info/top_level.txt,sha256=v0WgE1z2iCy_bXU53fVcllwHLTvGNBIvq8u3KPC2_Sc,7
-ipspot-0.5.dist-info/RECORD,,