ipspot 0.6__py3-none-any.whl → 0.8__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

@@ -36,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.
 
@@ -64,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.
 
@@ -92,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.
 
@@ -120,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.
 
@@ -148,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.
 
@@ -176,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.
 
@@ -206,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.
 
@@ -235,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.
 
@@ -263,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.
 
@@ -291,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.
 
@@ -319,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.
@@ -348,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.
@@ -377,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.
@@ -407,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.
@@ -437,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.
@@ -465,6 +466,62 @@ def _wtfismyip_com_ipv4(geo: bool=False, timeout: Union[float, Tuple[float, floa
         return {"status": False, "error": str(e)}
 
 
+def _myip_wtf_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.wtf.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_standard(url="https://json.ipv4.myip.wtf", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["YourFuckingIPAddress"], "api": "myip.wtf"}}
+        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 _db_ip_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 db-ip.com.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_force_ip(url="https://api.db-ip.com/v2/free/self", timeout=timeout, version="ipv4")
+        result = {"status": True, "data": {"ip": data["ipAddress"], "api": "db-ip.com"}}
+        if geo:
+            geo_data = {
+                "city": data.get("city"),
+                "region": data.get("stateProv"),
+                "country": data.get("countryName"),
+                "country_code": data.get("countryCode"),
+                "latitude": None,  # not provided by free API
+                "longitude": None,  # not provided by free API
+                "organization": None,  # not provided by free API
+                "timezone": None  # not provided by free API
+            }
+            result["data"].update(geo_data)
+        return result
+    except Exception as e:
+        return {"status": False, "error": str(e)}
+
+
 IPV4_API_MAP = {
     IPv4API.IFCONFIG_CO: {
         "thread_safe": False,
@@ -541,13 +598,24 @@ IPV4_API_MAP = {
         "geo": True,
         "function": _wtfismyip_com_ipv4
     },
+    IPv4API.MYIP_WTF: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _myip_wtf_ipv4
+    },
+    IPv4API.DB_IP_COM: {
+        "thread_safe": False,
+        "geo": True,
+        "function": _db_ip_com_ipv4
+    },
 }
 
 
-def get_public_ipv4(api: IPv4API=IPv4API.AUTO_SAFE, geo: bool=False,
-                    timeout: Union[float, Tuple[float, float]]=5,
+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.
 
@@ -556,6 +624,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():
@@ -566,6 +635,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"]:
@@ -579,6 +649,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

@@ -37,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.
 
@@ -65,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.
 
@@ -93,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.
 
@@ -121,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.
 
@@ -149,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.
 
@@ -177,8 +177,9 @@ def _my_ip_io_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _ifconfig_co_ipv6(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_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.
 
@@ -205,8 +206,8 @@ def _ifconfig_co_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]
         return {"status": False, "error": str(e)}
 
 
-def _reallyfreegeoip_org_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                              =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+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.
 
@@ -233,8 +234,8 @@ def _reallyfreegeoip_org_ipv6(geo: bool=False, timeout: Union[float, Tuple[float
         return {"status": False, "error": str(e)}
 
 
-def _myip_la_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                  =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+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.
 
@@ -262,8 +263,8 @@ def _myip_la_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
         return {"status": False, "error": str(e)}
 
 
-def _freeipapi_com_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, float]]
-                        =5) -> Dict[str, Union[bool, Dict[str, Union[str, float]], str]]:
+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.
 
@@ -291,6 +292,62 @@ def _freeipapi_com_ipv6(geo: bool=False, timeout: Union[float, Tuple[float, floa
         return {"status": False, "error": str(e)}
 
 
+def _wtfismyip_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 wtfismyip.com.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_standard(url="https://json.ipv6.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 _myip_wtf_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.wtf.
+
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    try:
+        data = _get_json_standard(url="https://json.ipv6.myip.wtf", timeout=timeout)
+        result = {"status": True, "data": {"ip": data["YourFuckingIPAddress"], "api": "myip.wtf"}}
+        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)}
+
+
 IPV6_API_MAP = {
     IPv6API.IP_SB: {
         "thread_safe": True,
@@ -336,14 +393,25 @@ IPV6_API_MAP = {
         "thread_safe": False,
         "geo": True,
         "function": _freeipapi_com_ipv6
-    }
+    },
+    IPv6API.WTFISMYIP_COM: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _wtfismyip_com_ipv6
+    },
+    IPv6API.MYIP_WTF: {
+        "thread_safe": True,
+        "geo": True,
+        "function": _myip_wtf_ipv6
+    },
 }
 
 
-def get_public_ipv6(api: IPv6API=IPv6API.AUTO_SAFE, geo: bool=False,
-                    timeout: Union[float, Tuple[float, float]]=5,
+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.
 
@@ -352,6 +420,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():
@@ -362,6 +431,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"]:
@@ -375,6 +445,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,12 +2,12 @@
 """ipspot params."""
 from enum import Enum
 
-IPSPOT_VERSION = "0.6"
+IPSPOT_VERSION = "0.8"
 
 IPSPOT_OVERVIEW = '''
-IPSpot is a Python library for retrieving the current system's IP address and location information.
-It currently supports public and private IPv4 detection using multiple API providers with a fallback mechanism for reliability.
-Designed with simplicity and modularity in mind, IPSpot offers quick IP and geolocation lookups directly from your machine.
+IPSpot is a Python library for retrieving the current system's IP data and detailed location information such as region, longitude, and latitude.
+It supports both public and private IPv4 and IPv6 detection through multiple API providers, using a fallback mechanism for improved reliability.
+It has a simple and modular design, making it easy to perform fast IP, geolocation, provider, and regional lookups directly from your machine.
 '''
 
 IPSPOT_REPO = "https://github.com/openscilab/ipspot"
@@ -38,6 +38,8 @@ class IPv4API(Enum):
     IPQUERY_IO = "ipquery.io"
     IPWHO_IS = "ipwho.is"
     WTFISMYIP_COM = "wtfismyip.com"
+    MYIP_WTF = "myip.wtf"
+    DB_IP_COM = "db-ip.com"
 
 
 class IPv6API(Enum):
@@ -54,6 +56,8 @@ class IPv6API(Enum):
     REALLYFREEGEOIP_ORG = "reallyfreegeoip.org"
     MYIP_LA = "myip.la"
     FREEIPAPI_COM = "freeipapi.com"
+    WTFISMYIP_COM = "wtfismyip.com"
+    MYIP_WTF = "myip.wtf"
 
 
 PARAMETERS_NAME_MAP = {
@@ -68,3 +72,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

@@ -74,22 +74,27 @@ def _get_json_force_ip(url: str, timeout: Union[float, Tuple[float, float]],
 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.6.dist-info → ipspot-0.8.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: ipspot
-Version: 0.6
-Summary: IPSpot: A Python Tool to Fetch the System's IP Address
+Version: 0.8
+Summary: IPSpot: Retrieve IPv4/IPv6 Addresses with Geolocation Data
 Home-page: https://github.com/openscilab/ipspot
-Download-URL: https://github.com/openscilab/ipspot/tarball/v0.6
+Download-URL: https://github.com/openscilab/ipspot/tarball/v0.8
 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
+Keywords: ip ipv4 ipv6 geo geolocation network location ipspot cli
 Classifier: Development Status :: 4 - Beta
 Classifier: Natural Language :: English
 Classifier: License :: OSI Approved :: MIT License
@@ -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
@@ -50,7 +51,7 @@ Dynamic: summary
 
 <div align="center">
 <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>
+<h1>IPSpot: Retrieve IPv4/IPv6 Addresses with Geolocation Data</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>
@@ -62,7 +63,7 @@ Dynamic: summary
 ## Overview	
 
 <p align="justify">					
-<b>IPSpot</b> is a Python library for retrieving the current system's IP address and location information. It currently supports public and private <b>IPv4</b> detection using multiple API providers with a fallback mechanism for reliability. Designed with simplicity and modularity in mind, <b>IPSpot</b> offers quick IP and geolocation lookups directly from your machine.
+<b>IPSpot</b> is a Python library for retrieving the current system's IP data and detailed location information such as region, longitude, and latitude. It supports both public and private <b>IPv4</b> and <b>IPv6</b> detection through multiple API providers, using a fallback mechanism for improved reliability. It has a simple and modular design, making it easy to perform fast IP, geolocation, provider, and regional lookups directly from your machine.
 </p>
 
 <table>
@@ -103,13 +104,13 @@ Dynamic: summary
 ## Installation		
 
 ### Source Code
-- Download [Version 0.6](https://github.com/openscilab/ipspot/archive/v0.6.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
+- Download [Version 0.8](https://github.com/openscilab/ipspot/archive/v0.8.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.6`						
+- `pip install ipspot==0.8`						
 
 
 ## Usage
@@ -124,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}
 ```
 
@@ -144,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}
 ```
 
@@ -165,7 +166,7 @@ Dynamic: summary
 ```console
 > ipspot --version
 
-0.6
+0.8
 ```
 
 #### Info
@@ -173,24 +174,24 @@ Dynamic: summary
 ```console
 > ipspot --info
 
- ___  ____   ____                 _
-|_ _||  _ \ / ___|  _ __    ___  | |_
+ ___  ____   ____                 _   
+|_ _||  _ \ / ___|  _ __    ___  | |_ 
  | | | |_) |\___ \ | '_ \  / _ \ | __|
- | | |  __/  ___) || |_) || (_) || |_
+ | | |  __/  ___) || |_) || (_) || |_ 
 |___||_|    |____/ | .__/  \___/  \__|
-                   |_|
+                   |_|                
 
-__     __     ___       __
-\ \   / / _  / _ \     / /_
- \ \ / / (_)| | | |   | '_ \
+__     __     ___       ___  
+\ \   / / _  / _ \     ( _ ) 
+ \ \ / / (_)| | | |    / _ \ 
   \ V /   _ | |_| | _ | (_) |
-   \_/   (_) \___/ (_) \___/
+   \_/   (_) \___/ (_) \___/ 
 
 
 
-IPSpot is a Python library for retrieving the current system's IP address and location information.
-It currently supports public and private IPv4 detection using multiple API providers with a fallback mechanism for reliability.
-Designed with simplicity and modularity in mind, IPSpot offers quick IP and geolocation lookups directly from your machine.
+IPSpot is a Python library for retrieving the current system's IP data and detailed location information such as region, longitude, and latitude.
+It supports both public and private IPv4 and IPv6 detection through multiple API providers, using a fallback mechanism for improved reliability.
+It has a simple and modular design, making it easy to perform fast IP, geolocation, provider, and regional lookups directly from your machine.
 
 Repo : https://github.com/openscilab/ipspot
 
@@ -237,7 +238,7 @@ Public IP and Location Info:
 
 #### IPv4 API
 
-ℹ️ `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`, `ipquery.io`, `ipwho.is`, `wtfismyip.com`]
+ℹ️ `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`, `ipquery.io`, `ipwho.is`, `wtfismyip.com`, `myip.wtf`, `db-ip.com`]
 
 ℹ️ The default value: `auto-safe`
 
@@ -280,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`, `ifconfig.co`, `reallyfreegeoip.org`, `myip.la`, `freeipapi.com`]
+ℹ️ `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`, `wtfismyip.com`, `myip.wtf`]
 
 ℹ️ The default value: `auto-safe`
 
@@ -376,6 +377,25 @@ 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.8] - 2026-02-05
+### Added
+- Support [wtfismyip.com](https://wtfismyip.com/json) IPv6 API
+- Support [myip.wtf](https://myip.wtf/) IPv6 API
+- Support [myip.wtf](https://myip.wtf/) IPv4 API
+- Support [db-ip.com](https://api.db-ip.com/v2/free/self) IPv4 API
+### Changed
+- `README.md` updated
+## [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
@@ -468,7 +488,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.6...dev
+[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.8...dev
+[0.8]: https://github.com/openscilab/ipspot/compare/v0.7...v0.8
+[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

ipspot-0.8.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=QPTigPv5bIHX2FkCTZnnuq5-X4_i3_xRlk6d3U6VgfQ,24079
+ipspot/ipv6.py,sha256=wKEOcfGA-y-nuygU9KhqzULzRejEqZ5Dfr_mjHndEoA,16485
+ipspot/params.py,sha256=-j5WYVCWfa_Qdub5q8CELl1S8tq2wg7NbWbW4ilfE9o,2340
+ipspot/utils.py,sha256=W3HJ61_KVtdg4gWr4m9xXblQc_E30rJoF1aKk36Zqzg,4591
+ipspot-0.8.dist-info/licenses/AUTHORS.md,sha256=5ZvxP1KnuVkurB4psQDSqnqiAyn44q1aeiXUsnYgps4,411
+ipspot-0.8.dist-info/licenses/LICENSE,sha256=0aOd4wzZRoSH_35UZXRHS7alPFTtuFEBJrajLuonEIw,1067
+ipspot-0.8.dist-info/METADATA,sha256=QG5WjBJEl7Iz0V2MlmB5G0l_xreUHx79A_ApdrAEPVM,15986
+ipspot-0.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ipspot-0.8.dist-info/entry_points.txt,sha256=DJVLepYr8H3UcvWekU5Jy-tcr_xmWrphzgWGNOd3hlk,43
+ipspot-0.8.dist-info/top_level.txt,sha256=v0WgE1z2iCy_bXU53fVcllwHLTvGNBIvq8u3KPC2_Sc,7
+ipspot-0.8.dist-info/RECORD,,

{ipspot-0.6.dist-info → ipspot-0.8.dist-info}/WHEEL

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

ipspot-0.6.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=ZTv4HFyyxpiF8X-N8Pgk9_aJ7f9T58SpuuB3UKS0WII,21571
-ipspot/ipv6.py,sha256=zqP_ImJQeKpVIhmGQZmPLJsOuviUNnVg70tVhk4UQU0,13991
-ipspot/params.py,sha256=UqhiD8ybTnxRpecZ9RudKXxXyD-j63z23b6Cqbv1LJs,1881
-ipspot/utils.py,sha256=wZxz6e14aDqK0g27AdiRMrbiz8pk4UfxZvbFRDZzhSI,4445
-ipspot-0.6.dist-info/licenses/AUTHORS.md,sha256=5ZvxP1KnuVkurB4psQDSqnqiAyn44q1aeiXUsnYgps4,411
-ipspot-0.6.dist-info/licenses/LICENSE,sha256=0aOd4wzZRoSH_35UZXRHS7alPFTtuFEBJrajLuonEIw,1067
-ipspot-0.6.dist-info/METADATA,sha256=tYTL9nqZZP5YhOzV0IE2Y0CkUAytt-7b_dXWAdUCO08,14879
-ipspot-0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ipspot-0.6.dist-info/entry_points.txt,sha256=DJVLepYr8H3UcvWekU5Jy-tcr_xmWrphzgWGNOd3hlk,43
-ipspot-0.6.dist-info/top_level.txt,sha256=v0WgE1z2iCy_bXU53fVcllwHLTvGNBIvq8u3KPC2_Sc,7
-ipspot-0.6.dist-info/RECORD,,