ipspot 0.2__tar.gz → 0.3__tar.gz

{ipspot-0.2 → ipspot-0.3}/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.3] - 2025-05-19
+### Added
+- `is_ipv4` function
+- `is_loopback` function
+- `IPv4HTTPAdapter` class
+- Support [ident.me](https://ident.me/json)
+- Support [tnedi.me](https://tnedi.me/json)
+### Changed
+- `get_private_ipv4` function modified
+- `get_public_ipv4` function modified
+- `_ipsb_ipv4` function modified
+- `_ipapi_ipv4` function modified
+- `_ipinfo_ipv4` function modified
+- `functions.py` renamed to `utils.py` 
+- CLI functions moved to `cli.py`
+- IPv4 functions moved to `ipv4.py`
+- Test system modified
 ## [0.2] - 2025-05-04
 ### Added
 - Support [ip.sb](https://api.ip.sb/geoip)
@@ -24,7 +41,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.2...dev
+[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.3...dev
+[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.2 → ipspot-0.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ipspot
-Version: 0.2
+Version: 0.3
 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.2
+Download-URL: https://github.com/openscilab/ipspot/tarball/v0.3
 Author: IPSpot Development Team
 Author-email: ipspot@openscilab.com
 License: MIT
@@ -102,13 +102,13 @@ Dynamic: summary
 ## Installation		
 
 ### Source Code
-- Download [Version 0.2](https://github.com/openscilab/ipspot/archive/v0.2.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
+- Download [Version 0.3](https://github.com/openscilab/ipspot/archive/v0.3.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.2`						
+- `pip install ipspot==0.3`						
 
 
 ## Usage
@@ -142,7 +142,7 @@ Dynamic: summary
 ```console
 > ipspot --version
 
-0.2
+0.3
 ```
 
 #### Info
@@ -157,11 +157,11 @@ Dynamic: summary
 |___||_|    |____/ | .__/  \___/  \__|
                    |_|
 
-__     __     ___      ____
-\ \   / / _  / _ \    |___ \
- \ \ / / (_)| | | |     __) |
-  \ V /   _ | |_| | _  / __/
-   \_/   (_) \___/ (_)|_____|
+__     __     ___      _____
+\ \   / / _  / _ \    |___ /
+ \ \ / / (_)| | | |     |_ \
+  \ V /   _ | |_| | _  ___) |
+   \_/   (_) \___/ (_)|____/
 
 
 
@@ -197,7 +197,7 @@ Public IP and Location Info:
 
 #### IPv4 API
 
-ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`]
+ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`, `identme`, `tnedime`]
 
 ℹ️ The default value: `auto`
 
@@ -267,6 +267,23 @@ 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.3] - 2025-05-19
+### Added
+- `is_ipv4` function
+- `is_loopback` function
+- `IPv4HTTPAdapter` class
+- Support [ident.me](https://ident.me/json)
+- Support [tnedi.me](https://tnedi.me/json)
+### Changed
+- `get_private_ipv4` function modified
+- `get_public_ipv4` function modified
+- `_ipsb_ipv4` function modified
+- `_ipapi_ipv4` function modified
+- `_ipinfo_ipv4` function modified
+- `functions.py` renamed to `utils.py` 
+- CLI functions moved to `cli.py`
+- IPv4 functions moved to `ipv4.py`
+- Test system modified
 ## [0.2] - 2025-05-04
 ### Added
 - Support [ip.sb](https://api.ip.sb/geoip)
@@ -286,7 +303,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.2...dev
+[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.3...dev
+[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.2 → ipspot-0.3}/README.md

@@ -52,13 +52,13 @@
 ## Installation		
 
 ### Source Code
-- Download [Version 0.2](https://github.com/openscilab/ipspot/archive/v0.2.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
+- Download [Version 0.3](https://github.com/openscilab/ipspot/archive/v0.3.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.2`						
+- `pip install ipspot==0.3`						
 
 
 ## Usage
@@ -92,7 +92,7 @@
 ```console
 > ipspot --version
 
-0.2
+0.3
 ```
 
 #### Info
@@ -107,11 +107,11 @@
 |___||_|    |____/ | .__/  \___/  \__|
                    |_|
 
-__     __     ___      ____
-\ \   / / _  / _ \    |___ \
- \ \ / / (_)| | | |     __) |
-  \ V /   _ | |_| | _  / __/
-   \_/   (_) \___/ (_)|_____|
+__     __     ___      _____
+\ \   / / _  / _ \    |___ /
+ \ \ / / (_)| | | |     |_ \
+  \ V /   _ | |_| | _  ___) |
+   \_/   (_) \___/ (_)|____/
 
 
 
@@ -147,7 +147,7 @@ Public IP and Location Info:
 
 #### IPv4 API
 
-ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`]
+ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`, `identme`, `tnedime`]
 
 ℹ️ The default value: `auto`
 

{ipspot-0.2 → ipspot-0.3}/SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version       | Supported          |
 | ------------- | ------------------ |
-| 0.2           | :white_check_mark: |
-| < 0.2         | :x:                |
+| 0.3           | :white_check_mark: |
+| < 0.3         | :x:                |
 
 ## Reporting a Vulnerability
 

{ipspot-0.2 → ipspot-0.3}/ipspot/__init__.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 """ipspot modules."""
 from .params import IPSPOT_VERSION, IPv4API
-from .functions import get_private_ipv4, get_public_ipv4
+from .ipv4 import get_private_ipv4, get_public_ipv4, is_ipv4
+from .utils import is_loopback
 __version__ = IPSPOT_VERSION

{ipspot-0.2 → ipspot-0.3}/ipspot/__main__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """ipspot main."""
-from .functions import main
+from .cli import main
 
 
 if __name__ == "__main__":

ipspot-0.3/ipspot/cli.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""ipspot CLI."""
+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 .params import IPv4API, PARAMETERS_NAME_MAP
+from .params import IPSPOT_OVERVIEW, IPSPOT_REPO, IPSPOT_VERSION
+
+
+def ipspot_info() -> None:  # pragma: no cover
+    """Print ipspot details."""
+    tprint("IPSpot")
+    tprint("V:" + IPSPOT_VERSION)
+    print(IPSPOT_OVERVIEW)
+    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
+    """
+    Print collected IP and location data.
+
+    :param ipv4_api: public IPv4 API
+    :param geo: geolocation flag
+    :param timeout: timeout value for API
+    """
+    private_result = get_private_ipv4()
+    print("Private IP:\n")
+    print("  IP: {private_result[data][ip]}".format(private_result=private_result) if private_result["status"]
+          else "  Error: {private_result[error]}".format(private_result=private_result))
+
+    public_title = "\nPublic IP"
+    if geo:
+        public_title += " and Location Info"
+    public_title += ":\n"
+    print(public_title)
+    public_result = get_public_ipv4(ipv4_api, geo=geo, timeout=timeout)
+    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)))
+    else:
+        print("  Error: {public_result[error]}".format(public_result=public_result))
+
+
+def main() -> None:  # pragma: no cover
+    """CLI main function."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--ipv4-api',
+        help='public IPv4 API',
+        type=str.lower,
+        choices=[
+            x.value for x in IPv4API],
+        default=IPv4API.AUTO.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)
+
+    args = parser.parse_args()
+    if args.version:
+        print(IPSPOT_VERSION)
+    elif args.info:
+        ipspot_info()
+    else:
+        ipv4_api = IPv4API(args.ipv4_api)
+        geo = not args.no_geo
+        display_ip_info(ipv4_api=ipv4_api, geo=geo, timeout=args.timeout)

ipspot-0.3/ipspot/ipv4.py

@@ -0,0 +1,273 @@
+# -*- coding: utf-8 -*-
+"""ipspot ipv4 functions."""
+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
+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 is_ipv4(ip: str) -> bool:
+    """
+    Check if the given input is a valid IPv4 address.
+
+    :param ip: input IP
+    """
+    if not isinstance(ip, str):
+        return False
+    try:
+        _ = ipaddress.IPv4Address(ip)
+        return True
+    except Exception:
+        return False
+
+
+def get_private_ipv4() -> Dict[str, Union[bool, Dict[str, str], str]]:
+    """Retrieve the private IPv4 address."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(('192.168.1.1', 1))
+            private_ip = s.getsockname()[0]
+        if is_ipv4(private_ip) and not is_loopback(private_ip):
+            return {"status": True, "data": {"ip": private_ip}}
+        return {"status": False, "error": "Could not identify a non-loopback IPv4 address for this system."}
+    except Exception as e:
+        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]]:
+    """
+    Get public IP and geolocation using ip.sb.
+
+    :param geo: geolocation flag
+    :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
+    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]]:
+    """
+    Get public IP and geolocation using ip-api.com.
+
+    :param geo: geolocation flag
+    :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
+    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]]:
+    """
+    Get public IP and geolocation using ipinfo.io.
+
+    :param geo: geolocation flag
+    :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
+    except Exception as e:
+        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]]:
+    """
+    Get public IP and geolocation using ident.me.
+
+    :param geo: geolocation flag
+    :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
+    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]]:
+    """
+    Get public IP and geolocation using tnedi.me.
+
+    :param geo: geolocation flag
+    :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
+    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]]:
+    """
+    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
+    """
+    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 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)
+        return {"status": False, "error": "Unsupported API: {api}".format(api=api)}

{ipspot-0.2 → ipspot-0.3}/ipspot/params.py

@@ -2,7 +2,7 @@
 """ipspot params."""
 from enum import Enum
 
-IPSPOT_VERSION = "0.2"
+IPSPOT_VERSION = "0.3"
 
 IPSPOT_OVERVIEW = '''
 IPSpot is a Python library for retrieving the current system's IP address and location information.
@@ -25,6 +25,8 @@ class IPv4API(Enum):
     IPAPI = "ipapi"
     IPINFO = "ipinfo"
     IPSB = "ipsb"
+    IDENTME = "identme"
+    TNEDIME = "tnedime"
 
 
 PARAMETERS_NAME_MAP = {

ipspot-0.3/ipspot/utils.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""ipspot utils."""
+import ipaddress
+from typing import Any
+
+
+def is_loopback(ip: str) -> bool:
+    """
+    Check if the given input IP is a loopback address.
+
+    :param ip: input IP
+    """
+    try:
+        ip_object = ipaddress.ip_address(ip)
+        return ip_object.is_loopback
+    except Exception:
+        return False
+
+
+def filter_parameter(parameter: Any) -> Any:
+    """
+    Filter input parameter.
+
+    :param parameter: input parameter
+    """
+    if parameter is None:
+        return "N/A"
+    if isinstance(parameter, str) and len(parameter.strip()) == 0:
+        return "N/A"
+    return parameter

{ipspot-0.2 → ipspot-0.3}/ipspot.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ipspot
-Version: 0.2
+Version: 0.3
 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.2
+Download-URL: https://github.com/openscilab/ipspot/tarball/v0.3
 Author: IPSpot Development Team
 Author-email: ipspot@openscilab.com
 License: MIT
@@ -102,13 +102,13 @@ Dynamic: summary
 ## Installation		
 
 ### Source Code
-- Download [Version 0.2](https://github.com/openscilab/ipspot/archive/v0.2.zip) or [Latest Source](https://github.com/openscilab/ipspot/archive/dev.zip)
+- Download [Version 0.3](https://github.com/openscilab/ipspot/archive/v0.3.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.2`						
+- `pip install ipspot==0.3`						
 
 
 ## Usage
@@ -142,7 +142,7 @@ Dynamic: summary
 ```console
 > ipspot --version
 
-0.2
+0.3
 ```
 
 #### Info
@@ -157,11 +157,11 @@ Dynamic: summary
 |___||_|    |____/ | .__/  \___/  \__|
                    |_|
 
-__     __     ___      ____
-\ \   / / _  / _ \    |___ \
- \ \ / / (_)| | | |     __) |
-  \ V /   _ | |_| | _  / __/
-   \_/   (_) \___/ (_)|_____|
+__     __     ___      _____
+\ \   / / _  / _ \    |___ /
+ \ \ / / (_)| | | |     |_ \
+  \ V /   _ | |_| | _  ___) |
+   \_/   (_) \___/ (_)|____/
 
 
 
@@ -197,7 +197,7 @@ Public IP and Location Info:
 
 #### IPv4 API
 
-ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`]
+ℹ️ `ipv4-api` valid choices: [`auto`, `ipapi`, `ipinfo`, `ipsb`, `identme`, `tnedime`]
 
 ℹ️ The default value: `auto`
 
@@ -267,6 +267,23 @@ 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.3] - 2025-05-19
+### Added
+- `is_ipv4` function
+- `is_loopback` function
+- `IPv4HTTPAdapter` class
+- Support [ident.me](https://ident.me/json)
+- Support [tnedi.me](https://tnedi.me/json)
+### Changed
+- `get_private_ipv4` function modified
+- `get_public_ipv4` function modified
+- `_ipsb_ipv4` function modified
+- `_ipapi_ipv4` function modified
+- `_ipinfo_ipv4` function modified
+- `functions.py` renamed to `utils.py` 
+- CLI functions moved to `cli.py`
+- IPv4 functions moved to `ipv4.py`
+- Test system modified
 ## [0.2] - 2025-05-04
 ### Added
 - Support [ip.sb](https://api.ip.sb/geoip)
@@ -286,7 +303,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.2...dev
+[Unreleased]: https://github.com/openscilab/ipspot/compare/v0.3...dev
+[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.2 → ipspot-0.3}/ipspot.egg-info/SOURCES.txt

@@ -9,13 +9,15 @@ requirements.txt
 setup.py
 ipspot/__init__.py
 ipspot/__main__.py
-ipspot/functions.py
+ipspot/cli.py
+ipspot/ipv4.py
 ipspot/params.py
+ipspot/utils.py
 ipspot.egg-info/PKG-INFO
 ipspot.egg-info/SOURCES.txt
 ipspot.egg-info/dependency_links.txt
 ipspot.egg-info/entry_points.txt
 ipspot.egg-info/requires.txt
 ipspot.egg-info/top_level.txt
-tests/test_functions.py
-tests/test_ipv4.py
+tests/test_ipv4.py
+tests/test_utils.py

ipspot-0.3/ipspot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ipspot = ipspot.cli:main

{ipspot-0.2 → ipspot-0.3}/setup.py

@@ -32,7 +32,7 @@ def read_description() -> str:
 setup(
     name='ipspot',
     packages=['ipspot'],
-    version='0.2',
+    version='0.3',
     description='IPSpot: A Python Tool to Fetch the System\'s IP Address',
     long_description=read_description(),
     long_description_content_type='text/markdown',
@@ -40,7 +40,7 @@ setup(
     author='IPSpot Development Team',
     author_email='ipspot@openscilab.com',
     url='https://github.com/openscilab/ipspot',
-    download_url='https://github.com/openscilab/ipspot/tarball/v0.2',
+    download_url='https://github.com/openscilab/ipspot/tarball/v0.3',
     keywords="ip ipv4 geo geolocation network location ipspot cli",
     project_urls={
         'Source': 'https://github.com/openscilab/ipspot'
@@ -69,7 +69,7 @@ setup(
     license='MIT',
     entry_points={
             'console_scripts': [
-                'ipspot = ipspot.functions:main',
+                'ipspot = ipspot.cli:main',
             ]
     }
 )

ipspot-0.3/tests/test_ipv4.py

@@ -0,0 +1,202 @@
+from unittest import mock
+import requests
+from ipspot import get_private_ipv4, is_ipv4
+from ipspot import get_public_ipv4, IPv4API
+from ipspot import is_loopback
+
+TEST_CASE_NAME = "IPv4 tests"
+DATA_ITEMS = {'country_code', 'latitude', 'longitude', 'api', 'country', 'timezone', 'organization', 'region', 'ip', 'city'}
+
+
+def test_is_ipv4_1():
+    assert is_ipv4("192.168.0.1")
+
+
+def test_is_ipv4_2():
+    assert is_ipv4("0.0.0.0")
+
+
+def test_is_ipv4_3():
+    assert is_ipv4("255.255.255.255")
+
+
+def test_is_ipv4_4():
+    assert not is_ipv4("256.0.0.1")
+
+
+def test_is_ipv4_5():
+    assert not is_ipv4("abc.def.ghi.jkl")
+
+
+def test_is_ipv4_6():
+    assert not is_ipv4(123)
+
+
+def test_is_ipv4_7():
+    assert not is_ipv4("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+
+
+def test_is_loopback_1():
+    assert not is_loopback("192.168.0.1")
+
+
+def test_is_loopback_2():
+    assert is_loopback("127.0.0.1")
+
+
+def test_is_loopback_3():
+    assert is_loopback("127.255.255.255")
+
+
+def test_is_loopback_4():
+    assert not is_loopback("abc.def.ghi.jkl")
+
+
+def test_private_ipv4_success():
+    result = get_private_ipv4()
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert not is_loopback(result["data"]["ip"])
+
+
+def test_get_private_ipv4_loopback():
+    mock_socket = mock.MagicMock()
+    mock_socket.__enter__.return_value.getsockname.return_value = ('127.0.0.1',)
+    with mock.patch('socket.socket', return_value=mock_socket):
+        result = get_private_ipv4()
+        assert not result["status"]
+        assert result["error"] == "Could not identify a non-loopback IPv4 address for this system."
+
+
+def test_get_private_ipv4_exception():
+    with mock.patch('socket.socket', side_effect=Exception("Test error")):
+        result = get_private_ipv4()
+        assert not result["status"]
+        assert result["error"] == "Test error"
+
+
+def test_public_ipv4_auto_success():
+    result = get_public_ipv4(api=IPv4API.AUTO, geo=True)
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert set(result["data"].keys()) == DATA_ITEMS
+
+
+def test_public_ipv4_auto_timeout_error():
+    result = get_public_ipv4(api=IPv4API.AUTO, geo=True, timeout="5")
+    assert not result["status"]
+
+
+def test_public_ipv4_auto_net_error():
+    with mock.patch.object(requests.Session, "get", side_effect=Exception("No Internet")):
+        result = get_public_ipv4(api=IPv4API.AUTO)
+        assert not result["status"]
+        assert result["error"] == "All attempts failed."
+
+
+def test_public_ipv4_ipapi_success():
+    result = get_public_ipv4(api=IPv4API.IPAPI, geo=True)
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert set(result["data"].keys()) == DATA_ITEMS
+    assert result["data"]["api"] == "ip-api.com"
+
+
+def test_public_ipv4_ipapi_timeout_error():
+    result = get_public_ipv4(api=IPv4API.IPAPI, geo=True, timeout="5")
+    assert not result["status"]
+
+
+def test_public_ipv4_ipapi_net_error():
+    with mock.patch.object(requests.Session, "get", side_effect=Exception("No Internet")):
+        result = get_public_ipv4(api=IPv4API.IPAPI)
+        assert not result["status"]
+        assert result["error"] == "No Internet"
+
+
+def test_public_ipv4_ipinfo_success():
+    result = get_public_ipv4(api=IPv4API.IPINFO, geo=True)
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert set(result["data"].keys()) == DATA_ITEMS
+    assert result["data"]["api"] == "ipinfo.io"
+
+
+def test_public_ipv4_ipinfo_timeout_error():
+    result = get_public_ipv4(api=IPv4API.IPINFO, geo=True, timeout="5")
+    assert not result["status"]
+
+
+def test_public_ipv4_ipinfo_net_error():
+    with mock.patch.object(requests.Session, "get", side_effect=Exception("No Internet")):
+        result = get_public_ipv4(api=IPv4API.IPINFO)
+        assert not result["status"]
+        assert result["error"] == "No Internet"
+
+
+def test_public_ipv4_ipsb_success():
+    result = get_public_ipv4(api=IPv4API.IPSB, geo=True, timeout=30)
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert set(result["data"].keys()) == DATA_ITEMS
+    assert result["data"]["api"] == "ip.sb"
+
+
+def test_public_ipv4_ipsb_timeout_error():
+    result = get_public_ipv4(api=IPv4API.IPSB, geo=True, timeout="5")
+    assert not result["status"]
+
+
+
+def test_public_ipv4_ipsb_net_error():
+    with mock.patch.object(requests.Session, "get", side_effect=Exception("No Internet")):
+        result = get_public_ipv4(api=IPv4API.IPSB)
+        assert not result["status"]
+        assert result["error"] == "No Internet"
+
+
+def test_public_ipv4_identme_success():
+    result = get_public_ipv4(api=IPv4API.IDENTME, geo=True)
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert set(result["data"].keys()) == DATA_ITEMS
+    assert result["data"]["api"] == "ident.me"
+
+
+def test_public_ipv4_identme_timeout_error():
+    result = get_public_ipv4(api=IPv4API.IDENTME, geo=True, timeout="5")
+    assert not result["status"]
+
+
+def test_public_ipv4_identme_net_error():
+    with mock.patch.object(requests.Session, "get", side_effect=Exception("No Internet")):
+        result = get_public_ipv4(api=IPv4API.IDENTME)
+        assert not result["status"]
+        assert result["error"] == "No Internet"
+
+
+def test_public_ipv4_tnedime_success():
+    result = get_public_ipv4(api=IPv4API.TNEDIME, geo=True)
+    assert result["status"]
+    assert is_ipv4(result["data"]["ip"])
+    assert set(result["data"].keys()) == DATA_ITEMS
+    assert result["data"]["api"] == "tnedi.me"
+
+
+def test_public_ipv4_tnedime_timeout_error():
+    result = get_public_ipv4(api=IPv4API.TNEDIME, geo=True, timeout="5")
+    assert not result["status"]
+
+
+def test_public_ipv4_tnedime_net_error():
+    with mock.patch.object(requests.Session, "get", side_effect=Exception("No Internet")):
+        result = get_public_ipv4(api=IPv4API.TNEDIME)
+        assert not result["status"]
+        assert result["error"] == "No Internet"
+
+
+def test_public_ipv4_api_error():
+    result = get_public_ipv4(api="api1", geo=True)
+    assert not result["status"]
+    assert result["error"] == "Unsupported API: api1"
+

ipspot-0.2/tests/test_functions.py → ipspot-0.3/tests/test_utils.py

@@ -1,6 +1,6 @@
-from ipspot.functions import filter_parameter
+from ipspot.utils import filter_parameter
 
-TEST_CASE_NAME = "Functions tests"
+TEST_CASE_NAME = "Utils tests"
 
 
 def test_filter_parameter1():

ipspot-0.2/ipspot/functions.py

@@ -1,218 +0,0 @@
-# -*- coding: utf-8 -*-
-"""ipspot functions."""
-import argparse
-import socket
-from typing import Union, Dict, Tuple, Any
-import requests
-from art import tprint
-from .params import REQUEST_HEADERS, IPv4API, PARAMETERS_NAME_MAP
-from .params import IPSPOT_OVERVIEW, IPSPOT_REPO, IPSPOT_VERSION
-
-
-def ipspot_info() -> None:  # pragma: no cover
-    """Print ipspot details."""
-    tprint("IPSpot")
-    tprint("V:" + IPSPOT_VERSION)
-    print(IPSPOT_OVERVIEW)
-    print("Repo : " + IPSPOT_REPO)
-
-
-def get_private_ipv4() -> Dict[str, Union[bool, Dict[str, str], str]]:
-    """Retrieve the private IPv4 address."""
-    try:
-        hostname = socket.gethostname()
-        private_ip = socket.gethostbyname(hostname)
-        return {"status": True, "data": {"ip": private_ip}}
-    except Exception as e:
-        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]]:
-    """
-    Get public IP and geolocation using ip.sb.
-
-    :param geo: geolocation flag
-    :param timeout: timeout value for API
-    """
-    try:
-        response = requests.get("https://api.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
-    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]]:
-    """
-    Get public IP and geolocation using ip-api.com.
-
-    :param geo: geolocation flag
-    :param timeout: timeout value for API
-    """
-    try:
-        response = requests.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
-    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]]:
-    """
-    Get public IP and geolocation using ipinfo.io.
-
-    :param geo: geolocation flag
-    :param timeout: timeout value for API
-    """
-    try:
-        response = requests.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
-    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]]:
-    """
-    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
-    """
-    api_map = {
-        IPv4API.IPAPI: _ipapi_ipv4,
-        IPv4API.IPINFO: _ipinfo_ipv4,
-        IPv4API.IPSB: _ipsb_ipv4
-    }
-
-    if api == IPv4API.AUTO:
-        for _, func in api_map.items():
-            result = func(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)
-        return {"status": False, "error": "Unsupported API: {api}".format(api=api)}
-
-
-def filter_parameter(parameter: Any) -> Any:
-    """
-    Filter input parameter.
-
-    :param parameter: input parameter
-    """
-    if parameter is None:
-        return "N/A"
-    if isinstance(parameter, str) and len(parameter.strip()) == 0:
-        return "N/A"
-    return parameter
-
-
-def display_ip_info(ipv4_api: IPv4API = IPv4API.AUTO, geo: bool=False,
-                    timeout: Union[float, Tuple[float, float]]=5) -> 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
-    """
-    private_result = get_private_ipv4()
-    print("Private IP:\n")
-    print("  IP: {private_result[data][ip]}".format(private_result=private_result) if private_result["status"]
-          else "  Error: {private_result[error]}".format(private_result=private_result))
-
-    public_title = "\nPublic IP"
-    if geo:
-        public_title += " and Location Info"
-    public_title += ":\n"
-    print(public_title)
-    public_result = get_public_ipv4(ipv4_api, geo=geo, timeout=timeout)
-    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)))
-    else:
-        print("  Error: {public_result[error]}".format(public_result=public_result))
-
-
-def main() -> None:  # pragma: no cover
-    """CLI main function."""
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        '--ipv4-api',
-        help='public IPv4 API',
-        type=str.lower,
-        choices=[
-            x.value for x in IPv4API],
-        default=IPv4API.AUTO.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)
-
-    args = parser.parse_args()
-    if args.version:
-        print(IPSPOT_VERSION)
-    elif args.info:
-        ipspot_info()
-    else:
-        ipv4_api = IPv4API(args.ipv4_api)
-        geo = not args.no_geo
-        display_ip_info(ipv4_api=ipv4_api, geo=geo, timeout=args.timeout)

ipspot-0.2/ipspot.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-ipspot = ipspot.functions:main

ipspot-0.2/tests/test_ipv4.py

@@ -1,108 +0,0 @@
-import re
-from unittest import mock
-from ipspot import get_private_ipv4
-from ipspot import get_public_ipv4, IPv4API
-
-TEST_CASE_NAME = "IPv4 tests"
-IPV4_REGEX = re.compile(r'^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$')
-DATA_ITEMS = {'country_code', 'latitude', 'longitude', 'api', 'country', 'timezone', 'organization', 'region', 'ip', 'city'}
-
-
-def test_private_ipv4_success():
-    result = get_private_ipv4()
-    assert result["status"]
-    assert IPV4_REGEX.match(result["data"]["ip"])
-
-
-def test_private_ipv4_error():
-    with mock.patch("socket.gethostbyname", side_effect=Exception("Test error")):
-        result = get_private_ipv4()
-        assert not result["status"]
-        assert result["error"] == "Test error"
-
-
-def test_public_ipv4_auto_success():
-    result = get_public_ipv4(api=IPv4API.AUTO, geo=True)
-    assert result["status"]
-    assert IPV4_REGEX.match(result["data"]["ip"])
-    assert set(result["data"].keys()) == DATA_ITEMS
-
-
-def test_public_ipv4_auto_timeout_error():
-    result = get_public_ipv4(api=IPv4API.AUTO, geo=True, timeout="5")
-    assert not result["status"]
-
-
-def test_public_ipv4_auto_net_error():
-    with mock.patch("requests.get", side_effect=Exception("No Internet")):
-        result = get_public_ipv4(api=IPv4API.AUTO)
-        assert not result["status"]
-        assert result["error"] == "All attempts failed."
-
-
-def test_public_ipv4_ipapi_success():
-    result = get_public_ipv4(api=IPv4API.IPAPI, geo=True)
-    assert result["status"]
-    assert IPV4_REGEX.match(result["data"]["ip"])
-    assert set(result["data"].keys()) == DATA_ITEMS
-    assert result["data"]["api"] == "ip-api.com"
-
-
-def test_public_ipv4_ipapi_timeout_error():
-    result = get_public_ipv4(api=IPv4API.IPAPI, geo=True, timeout="5")
-    assert not result["status"]
-
-
-def test_public_ipv4_ipapi_net_error():
-    with mock.patch("requests.get", side_effect=Exception("No Internet")):
-        result = get_public_ipv4(api=IPv4API.IPAPI)
-        assert not result["status"]
-        assert result["error"] == "No Internet"
-
-
-def test_public_ipv4_ipinfo_success():
-    result = get_public_ipv4(api=IPv4API.IPINFO, geo=True)
-    assert result["status"]
-    assert IPV4_REGEX.match(result["data"]["ip"])
-    assert set(result["data"].keys()) == DATA_ITEMS
-    assert result["data"]["api"] == "ipinfo.io"
-
-
-def test_public_ipv4_ipinfo_timeout_error():
-    result = get_public_ipv4(api=IPv4API.IPINFO, geo=True, timeout="5")
-    assert not result["status"]
-
-
-def test_public_ipv4_ipinfo_net_error():
-    with mock.patch("requests.get", side_effect=Exception("No Internet")):
-        result = get_public_ipv4(api=IPv4API.IPINFO)
-        assert not result["status"]
-        assert result["error"] == "No Internet"
-
-
-def test_public_ipv4_ipsb_success():
-    result = get_public_ipv4(api=IPv4API.IPSB, geo=True)
-    assert result["status"]
-    assert IPV4_REGEX.match(result["data"]["ip"])
-    assert set(result["data"].keys()) == DATA_ITEMS
-    assert result["data"]["api"] == "ip.sb"
-
-
-def test_public_ipv4_ipsb_timeout_error():
-    result = get_public_ipv4(api=IPv4API.IPSB, geo=True, timeout="5")
-    assert not result["status"]
-
-
-
-def test_public_ipv4_ipsb_net_error():
-    with mock.patch("requests.get", side_effect=Exception("No Internet")):
-        result = get_public_ipv4(api=IPv4API.IPSB)
-        assert not result["status"]
-        assert result["error"] == "No Internet"
-
-
-def test_public_ipv4_api_error():
-    result = get_public_ipv4(api="api1", geo=True)
-    assert not result["status"]
-    assert result["error"] == "Unsupported API: api1"
-