pyapiary 2.0.2__tar.gz → 2.1.4__tar.gz

{pyapiary-2.0.2 → pyapiary-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyapiary
-Version: 2.0.2
+Version: 2.1.4
 Summary: A simple, lightweight set of connectors and functions to various APIs and DBMSs, controlled by a central broker.
 Author: Rob D'Aveta
 Author-email: rob.daveta@gmail.com
@@ -36,24 +36,27 @@ New development and releases are published under the `pyapiary` package name.
 
 ## 📚 Table of Contents
 
-- [Installation](#installation)
-- [API Connectors](#api-connectors)
-  - [Async Support](#async-support)
-  - [Example (URLScan)](#example-urlscan)
-  - [Customizing API Requests with **kwargs](#customizing-api-requests-with-kwargs)
-- [DBMS Connectors](#dbms-connectors)
+- [Installation](#-installation)
+- [API Connectors](#-api-connectors)
+  - [Shared Features](#-shared-features)
+  - [Sync Example (URLScan)](#-sync-example-urlscan)
+  - [Async Example (URLScan)](#-async-example-urlscan)
+  - [Customizing API Requests with `**kwargs`](#customizing-api-requests-with-kwargs)
+  - [Proxy Awareness](#proxy-awareness)
+  - [SSL Verification and Per-Request Options](#ssl-verification-and-per-request-options)
+- [DBMS Connectors](#-dbms-connectors)
   - [MongoDB](#mongodb)
   - [Elasticsearch](#elasticsearch)
   - [ODBC](#odbc-eg-postgres-teradata)
   - [Splunk](#splunk)
-- [Testing](#testing)
-  - [Unit tests](#unit-tests)
-  - [Integration tests](#integration-tests)
-  - [Suppress warnings](#suppress-warnings)
-- [Contributing / Adding a Connector](#contributing--adding-a-connector)
-- [Dev Environment](#dev-environment)
-- [Secrets and Redaction](#secrets-and-redaction)
-- [Summary](#summary)
+- [Testing](#-testing)
+  - [Unit tests](#-unit-tests)
+  - [Integration tests](#-integration-tests)
+  - [Suppress warnings](#-suppress-warnings)
+- [Contributing / Adding a Connector](#-contributing--adding-a-connector)
+- [Dev Environment](#-dev-environment)
+- [Secrets and Redaction](#-secrets-and-redaction)
+- [Summary](#-summary)
 
 
 

{pyapiary-2.0.2 → pyapiary-2.1.4}/README.md

@@ -11,24 +11,27 @@ New development and releases are published under the `pyapiary` package name.
 
 ## 📚 Table of Contents
 
-- [Installation](#installation)
-- [API Connectors](#api-connectors)
-  - [Async Support](#async-support)
-  - [Example (URLScan)](#example-urlscan)
-  - [Customizing API Requests with **kwargs](#customizing-api-requests-with-kwargs)
-- [DBMS Connectors](#dbms-connectors)
+- [Installation](#-installation)
+- [API Connectors](#-api-connectors)
+  - [Shared Features](#-shared-features)
+  - [Sync Example (URLScan)](#-sync-example-urlscan)
+  - [Async Example (URLScan)](#-async-example-urlscan)
+  - [Customizing API Requests with `**kwargs`](#customizing-api-requests-with-kwargs)
+  - [Proxy Awareness](#proxy-awareness)
+  - [SSL Verification and Per-Request Options](#ssl-verification-and-per-request-options)
+- [DBMS Connectors](#-dbms-connectors)
   - [MongoDB](#mongodb)
   - [Elasticsearch](#elasticsearch)
   - [ODBC](#odbc-eg-postgres-teradata)
   - [Splunk](#splunk)
-- [Testing](#testing)
-  - [Unit tests](#unit-tests)
-  - [Integration tests](#integration-tests)
-  - [Suppress warnings](#suppress-warnings)
-- [Contributing / Adding a Connector](#contributing--adding-a-connector)
-- [Dev Environment](#dev-environment)
-- [Secrets and Redaction](#secrets-and-redaction)
-- [Summary](#summary)
+- [Testing](#-testing)
+  - [Unit tests](#-unit-tests)
+  - [Integration tests](#-integration-tests)
+  - [Suppress warnings](#-suppress-warnings)
+- [Contributing / Adding a Connector](#-contributing--adding-a-connector)
+- [Dev Environment](#-dev-environment)
+- [Secrets and Redaction](#-secrets-and-redaction)
+- [Summary](#-summary)
 
 
 

{pyapiary-2.0.2 → pyapiary-2.1.4}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "pyapiary"
 packages = [{ include = "pyapiary", from = "src" }]
-version = "2.0.2"
+version = "2.1.4"
 description = "A simple, lightweight set of connectors and functions to various APIs and DBMSs, controlled by a central broker."
 authors = ["Rob D'Aveta <rob.daveta@gmail.com>"]
 readme = "README.md"

{pyapiary-2.0.2 → pyapiary-2.1.4}/src/pyapiary/api_connectors/broker.py

@@ -19,8 +19,25 @@ def log_method_call(func: Callable[P, R]) -> Callable[P, R]:
         sig = inspect.signature(func)
         bound = sig.bind(self, *args, **kwargs)
         bound.apply_defaults()
-        query_value = bound.arguments.get("query")
-        self._log(f"{caller} called with query: {query_value}")
+        call_args = {k: v for k, v in bound.arguments.items() if k != "self"}
+        query_value = call_args.get("query")
+
+        if query_value is not None:
+            self._log(f"{caller} called with query: {query_value}")
+        elif call_args:
+            # Fall back to a compact arg summary for methods that don't use a
+            # positional/keyword `query` parameter (e.g., kwargs-only search APIs).
+            summary_parts = []
+            for key, value in call_args.items():
+                if key == "kwargs" and isinstance(value, dict):
+                    summary_parts.append(f"kwargs_keys={sorted(value.keys())}")
+                elif key == "params" and isinstance(value, dict):
+                    summary_parts.append(f"params_keys={sorted(value.keys())}")
+                else:
+                    summary_parts.append(f"{key}={value!r}")
+            self._log(f"{caller} called with {', '.join(summary_parts)}")
+        else:
+            self._log(f"{caller} called")
         return func(self, *args, **kwargs)
     return wrapper
 
@@ -119,9 +136,10 @@ class SharedConnectorBase:
         self.env_config = combine_env_configs() if load_env_vars else {}
         self._client_kwargs = dict(client_kwargs) if client_kwargs else {}
 
-    def _log(self, message: str):
+    def _log(self, message: str, level: str = "info"):
         if self.logger:
-            self.logger.info(message)
+            log_fn = getattr(self.logger, level, self.logger.info)
+            log_fn(message)
 
     def _collect_proxy_config(self) -> tuple[Optional[str], Optional[Dict[str, httpx.HTTPTransport]]]:
         source_env: Optional[Dict[str, str]] = None
@@ -273,10 +291,10 @@ class Broker(SharedConnectorBase):
             return call()
         except RetryError as re:
             last = re.last_attempt.exception()
-            self._log(f"Retry failed: {last}")
+            self._log(f"Retry failed: {last}", level="error")
             raise
         except httpx.HTTPStatusError as he:
-            self._log(f"HTTP error: {he}")
+            self._log(f"HTTP error: {he}", level="error")
             raise
 
     def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None, **kwargs) -> httpx.Response:
@@ -385,10 +403,10 @@ class AsyncBroker(SharedConnectorBase):
             return await call()
         except RetryError as re:
             last = re.last_attempt.exception()
-            self._log(f"Retry failed: {last}")
+            self._log(f"Retry failed: {last}", level="error")
             raise
         except httpx.HTTPStatusError as he:
-            self._log(f"HTTP error: {he}")
+            self._log(f"HTTP error: {he}", level="error")
             raise
 
     async def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None, **kwargs) -> httpx.Response:

pyapiary-2.1.4/src/pyapiary/api_connectors/domaintools.py

@@ -0,0 +1,241 @@
+import httpx
+from typing import Optional, Mapping, Any
+from pyapiary.api_connectors.broker import Broker, AsyncBroker, bubble_broker_init_signature, log_method_call
+
+IRIS_INVESTIGATE_ALLOWED_PARAMS = {
+    'active',
+    'adsense',
+    'baidu_analytics',
+    'contact_name',
+    'contact_phone',
+    'contact_street',
+    'create_date',
+    'domain',
+    'email',
+    'email_dns_soa',
+    'email_domain',
+    'expiration_date',
+    'facebook',
+    'first_seen_since',
+    'first_seen_within',
+    'google_analytics',
+    'google_analytics_4',
+    'google_tag_manager',
+    'historical_email',
+    'historical_free_text',
+    'historical_registrant',
+    'hotjar',
+    'iana_id',
+    'ip',
+    'ip_country_code',
+    'mailserver_domain',
+    'mailserver_host',
+    'mailserver_ip',
+    'matomo',
+    'nameserver_domain',
+    'nameserver_host',
+    'nameserver_ip',
+    'not_tagged_with_all',
+    'not_tagged_with_any',
+    'rank',
+    'redirect_domain',
+    'registrant',
+    'registrant_org',
+    'registrar',
+    'risk_score',
+    'search_hash',
+    'server_type',
+    'ssl_alt_names',
+    'ssl_common_name',
+    'ssl_duration',
+    'ssl_email',
+    'ssl_hash',
+    'ssl_issuer_common_name',
+    'ssl_not_after',
+    'ssl_not_before',
+    'ssl_org',
+    'ssl_subject',
+    'statcounter_project',
+    'statcounter_security',
+    'tagged_with_all',
+    'tagged_with_any',
+    'tld',
+    'website_title',
+    'whois',
+    'yandex_metrica'
+}
+
+def _validate_iris_investigate_params(params: Mapping[str, Any]) -> None:
+    if not params:
+        raise ValueError("At least one Iris Investigate parameter is required.")
+    invalid = set(params) - IRIS_INVESTIGATE_ALLOWED_PARAMS
+    if invalid:
+        raise ValueError(f"Invalid Iris Investigate parameters: {sorted(invalid)}")
+
+
+
+@bubble_broker_init_signature()
+class DomainToolsConnector(Broker):
+    def __init__(self, api_key: Optional[str] = None, **kwargs):
+        super().__init__(base_url="https://api.domaintools.com", **kwargs)
+
+        self.api_key = api_key or self.env_config.get("DOMAINTOOLS_API_KEY")
+        if not self.api_key:
+            raise ValueError("API key is required for DomainTools")
+        self.headers.update({"X-API-KEY": self.api_key})
+
+    @log_method_call
+    def iris_investigate(self, **kwargs) -> httpx.Response:
+        """Iris Investigate supports a set of base search parameters and filter
+        parameters. Base search parameters can be used on their own or in
+        combination with each other, while filter parameters refine the base search.
+        Documentation can be found here. https://docs.domaintools.com/api/iris/investigate/search/
+
+        Args:
+            **kwargs: Instead of a domain name, you can provide one or more search
+            fields to the API, such as IP address, SSL hash, email, or more, and
+            Iris Investigate will return any domain name with a record that matches
+            those parameters. This enables "reverse" searching on one or more fields
+            with a single API endpoint.
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        _validate_iris_investigate_params(kwargs)
+        return self.get("/v1/iris-investigate", params=kwargs)
+
+    @log_method_call
+    def parsed_whois(self, query: str, **kwargs) -> httpx.Response:
+        """The Parsed WHOIS API provides parsed information extracted from the
+        raw WHOIS record. The API is optimized to quickly retrieve the WHOIS
+        record, group important data together and return a well-structured
+        format. The Parsed WHOIS API is ideal for anyone wishing to search for,
+        index, or cross-reference data from one or multiple WHOIS records.
+
+        Args:
+            query (str): A valid domain name or IP address.
+
+            **kwargs: Additional keyword arguments to pass to the request as parameters
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        return self.get(f"v1/{query}/whois/parsed", **kwargs)
+
+    @log_method_call
+    def reverse_ip(self, query: str, **kwargs) -> httpx.Response:
+        """The Reverse IP API provides a list of domain names that share the same
+        Internet host (i.e. the same IP address). You can request an IP address
+        directly, or you can provide a domain name; if you provide a domain name,
+        the API will respond with the list of other domains that share the same IP.
+
+        Args:
+            query (str): A valid domain name.
+
+           **kwargs: Additional keyword arguments to pass to the request as parameters
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        return self.get(f"v1/{query}/reverse-ip", **kwargs)
+
+    @log_method_call
+    def reverse_nameserver(self, query: str, **kwargs) -> httpx.Response:
+        """The Reverse Name Server API provides a list of domain names that share
+        the same primary or secondary name server. You can provide a domain name
+        and the API will provide the list of domain names pointed to the same
+        name servers as those listed as the primary and secondary name servers
+        on the domain name you requested.
+
+        Args:
+            query (str): The name server hostname to query
+
+            **kwargs: Additional keyword arguments to pass to the request as parameters
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        return self.get(f"v1/{query}/name-server-domains", **kwargs)
+
+
+class AsyncDomainToolsConnector(AsyncBroker):
+    def __init__(self, api_key: Optional[str] = None, **kwargs):
+        super().__init__(base_url="https://api.domaintools.com", **kwargs)
+
+        self.api_key = api_key or self.env_config.get("DOMAINTOOLS_API_KEY")
+        if not self.api_key:
+            raise ValueError("API key is required for DomainTools")
+        self.headers.update({"X-API-KEY": self.api_key})
+
+    @log_method_call
+    async def iris_investigate(self, **kwargs) -> httpx.Response:
+        """Iris Investigate supports a set of base search parameters and filter
+        parameters. Base search parameters can be used on their own or in
+        combination with each other, while filter parameters refine the base search.
+        Documentation can be found here. https://docs.domaintools.com/api/iris/investigate/search/
+
+        Args:
+            **kwargs: Instead of a domain name, you can provide one or more search
+            fields to the API, such as IP address, SSL hash, email, or more, and
+            Iris Investigate will return any domain name with a record that matches
+            those parameters. This enables "reverse" searching on one or more fields
+            with a single API endpoint.
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        _validate_iris_investigate_params(kwargs)
+        return await self.get("/v1/iris-investigate", params=kwargs)
+
+    @log_method_call
+    async def parsed_whois(self, query: str, **kwargs) -> httpx.Response:
+        """The Parsed WHOIS API provides parsed information extracted from the
+        raw WHOIS record. The API is optimized to quickly retrieve the WHOIS
+        record, group important data together and return a well-structured
+        format. The Parsed WHOIS API is ideal for anyone wishing to search for,
+        index, or cross-reference data from one or multiple WHOIS records.
+
+        Args:
+            query (str): A valid domain name or IP address.
+
+            **kwargs: Additional keyword arguments to pass to the request as parameters
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        return await self.get(f"v1/{query}/whois/parsed", **kwargs)
+
+    @log_method_call
+    async def reverse_ip(self, query: str, **kwargs) -> httpx.Response:
+        """The Reverse IP API provides a list of domain names that share the same
+        Internet host (i.e. the same IP address). You can request an IP address
+        directly, or you can provide a domain name; if you provide a domain name,
+        the API will respond with the list of other domains that share the same IP.
+
+        Args:
+            query (str): A valid domain name.
+
+           **kwargs: Additional keyword arguments to pass to the request as parameters
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        return await self.get(f"v1/{query}/reverse-ip", **kwargs)
+
+    @log_method_call
+    async def reverse_nameserver(self, query: str, **kwargs) -> httpx.Response:
+        """The Reverse Name Server API provides a list of domain names that share
+        the same primary or secondary name server. You can provide a domain name
+        and the API will provide the list of domain names pointed to the same
+        name servers as those listed as the primary and secondary name servers
+        on the domain name you requested.
+
+        Args:
+            query (str): The name server hostname to query
+
+            **kwargs: Additional keyword arguments to pass to the request as parameters
+
+        Returns:
+            httpx.Response: The httpx response object.
+        """
+        return await self.get(f"v1/{query}/name-server-domains", **kwargs)

pyapiary-2.1.4/src/pyapiary/tests/test_domaintools/cassettes/.gitkeep

@@ -0,0 +1 @@
+

pyapiary-2.1.4/src/pyapiary/tests/test_domaintools/cassettes/test_domaintools_iris_investigate_vcr.yaml

@@ -0,0 +1,88 @@
+interactions:
+- request:
+    body: ''
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      host:
+      - api.domaintools.com
+      user-agent:
+      - REDACTED
+      x-api-key:
+      - REDACTED
+    method: GET
+    uri: https://api.domaintools.com/v1/iris-investigate?domain=domaintools.com
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA+1ZbW/bthb+K4Y/JyrfRIoBBjRLcy96b9sVadFh93YQaImy1UmiIFJNsiL/fYey
+        HUuy7MVdsE8DAiQizyEfPueF5zDf5o22tamsnl98mxd5mbtY3yVapzqdX2SqsPpsvlI2Lk2jY5Bt
+        C2cfJ0ptrVqC6vy6+mLuZ/embWapciqYn803wnFi2srNL/DZ3Bmnit7343L//zZPTanyClZa/+GM
+        KWyQmBIWul2Z3MZtU8DsyrnaXnx+8flFNxqMpD+/2FdXqdWb831VRevRwugGBXoAgULfqfkFlSE7
+        m9embgvV5O4+blT12/yCsIiATOLyr6DqmhbOvTRmWehYVaq4d3liD6+9VKw73nb23+c37998evvf
+        qx/pLztJ/PAriLoSuEm1HSp8fHsevif/uXo3Es8Wj9LwtTLui2r6IwuVp21/4F5Vqb7rj5TKmdL0
+        R6xTrttEN3HdmC86cYemrU7ajqbevErLvIKBygFfnpRKlQPib65fXV59vH41+9dPN7P3N68/XV71
+        aRASMcSpJ840yxMUCQbjSUQePMZGa3eCLiVYhAwz0E3gPKdohpIKiqKHNTOnnBSTEGFGPeDagHJx
+        yracCY67w3ZDzSmYMUIEESL9xitTHQmLTN0dntQQZcXAURudgtF1OstMM6ub/KtK7vv7ChZixh9+
+        BeVFXhR5tTzmKMPdRs4wnNw3+HB+bNSx9shww+l944wW3zfAaIFnINlz1uhlDidVlTtG26su+80u
+        fRx24s40fSNw8FgW7TO61vvos+bZ7M2bq51OOMkwwQjPmFvNLiEpPsoSMkH3B62cK3pSnHAZiSnq
+        f77cSQkCIcKm40NGEPA70UgyOW2K1u6kKAo5J4LSKaNggnhEI4lo2DuO2DfQo2DIeyeaDIhSlwvd
+        WN18zRNtX+5fTFtgYRcUTierKk+6C/Kf/PlP/hznTxaGcOjOVZIGYkrH6YgyLGV0juCH9GKDY7/b
+        XZ1DLshNtacEhxGdUi+gOKWEbUHG28qsh/WgL0tIFzsxXZlyOA9+RoiQoi9VWaAxqMDndssg8EjO
+        fZljjYr3yVqBzUtloQ55OaVOKBOSduq2eFTvCpQ09zRAlK2ryv2l1aK1+uU+dEwk41FE/Kp53anA
+        alDC2qENogAoDQjGQY9RykKEulrTDpgkSBJGdvRAYiS0K+82ntlVV4dSGo6k5Fhwn39yWw9SqV5k
+        hbmdva6SIQpwIb98edfB8Dz21ZStyzsWrOtbT82IA0o5Ev5K2DrFTvWQjiCSi9Cn0g1rO6pIgEUU
+        YAKU9bNpSCmEmUcJYWCaLqfA99kBuEGxwTtyNRFhYDc6AnaUh7mgEcHRPlLBAGQIdh3gJKEEo/IR
+        zoMwyUFWuRCShPSZWGXgfCEK4IIOiOglAnCsiLInsVo4HBynliAhmHgGak+CGx5AS/4ELdwWQqDn
+        QLt1Wc6GaCMBlcOT0Hqg9LArgC8gyp45wDzanuNKzGCXcM8V4NvXG7EvWXQzmR/SypKgRiyYyLpM
+        UiKnvXhKGm4m0hVje6ijIMQBCwM2XFtQf/lNYqJHMIVy2vLfg4kFPBoszuVhUOwwKBbKaRt/H1FD
+        UCw8whQ+wlSEppPl9zE1tB5nEB3ew9bLx01uf/N7+N+xTUwDysgrlDVsVm0ehdbl7/x33ZgC2hn/
+        qNSXf1g3Rmne6ORIA7iViPePNhZ87LFOa6wkkpxxMlzipBZrq9f0Va7f/fT2bPb63VXQ41IIKM9k
+        XyX2xXPrGZsnRQ7k+f1tppu6Mat8kUNROfelUJ3FeZWZ9bF9YbT+8mGu7GqQpRZKYUWShKNIcgV1
+        ZabCTCqktVYsyxDNdITQov8kBUu2iy8jQ1y9++H29nb8SjdUA55Ulf/eladP6IX9e93aPsOHsqP7
+        oH7BuSjM8omiR6S62rRtEt3Vf9v3QSyEv2wiaMIQ+HOtrN2M8wgJLjkPCe4aj7KEanzsZn9KVm5t
+        q/0736T6B6A/X5rZ+3ZR5MnsQ5fIZ5etW4FXQG/pKZ5dXc5efZrd0N6NAL4rqfRlZGVcrDKn+34I
+        9SxHEsten885FRvphc66aByKQ+m1u08hKaB1tdA2YzMT/+i6FaRQoT50mWvskBrKAb7QPBFcpZSg
+        DIkoxRlPU6lEJFIkqSIcP8Uh/w5n/Gt+c9g//oJv/HzdYydkIfRXETlmcdY3IYE2XcrnMbnE/YcH
+        znDERdeUuCIFoJtHf72wkLni3b8niA8o/8+FuK19F5vGLgfenSrrdR/LofM9J/wjZhcIQ0EDBTt0
+        66i3mMv9S9R0Uu4VjN51utCJ3X09kE8K06ZZoZreexZjIRSMwl+GWd5YB/WTHvgOAMfnGHloCF10
+        P/8b+pNTy+4FvevMwIz+cXRt6vXwwx9vgSK0pxkAAA==
+    headers:
+      access-control-allow-origin:
+      - '*'
+      cache-control:
+      - no-store, no-cache, must-revalidate
+      content-encoding:
+      - gzip
+      content-security-policy:
+      - 'default-src * data: blob: ''unsafe-eval'' ''unsafe-inline'''
+      content-type:
+      - application/json;charset=utf-8
+      date:
+      - Thu, 26 Feb 2026 15:47:26 GMT
+      expires:
+      - Thu, 19 Nov 1981 08:52:00 GMT
+      pragma:
+      - no-cache
+      server:
+      - Chuck Norris fears nothing that is not Emily.
+      set-cookie:
+      - dtsession=hqbf19kre196nc61pgjtm4cld8vcu5r9gl522scebk98c3n0hp9s8ed2s1mndnqguovi99bue8mp5n4jhhthrq7qscaaq5slug723q6;
+        expires=Sat, 28-Mar-2026 15:47:26 GMT; Max-Age=2592000; path=/; domain=.domaintools.com;
+        secure; HttpOnly
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains
+      transfer-encoding:
+      - chunked
+      vary:
+      - Accept-Encoding
+      x-time:
+      - '80027'
+    status:
+      code: 200
+      message: OK
+version: 1

pyapiary-2.1.4/src/pyapiary/tests/test_domaintools/cassettes/test_domaintools_parsed_whois_vcr.yaml

@@ -0,0 +1,77 @@
+interactions:
+- request:
+    body: ''
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      host:
+      - api.domaintools.com
+      user-agent:
+      - REDACTED
+      x-api-key:
+      - REDACTED
+    method: GET
+    uri: https://api.domaintools.com/v1/domaintools.com/whois/parsed
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA+1XXW/qOBD9Kxb7eGlIQkohTzcb6F6kNiACF927VFEILkQCO0pMP7bqf9+xHfIB
+        SYr2eSWEyMzx2HOOMzN8tGKcRJQkuGV+wO9tmLDYJ6xltob04IdkTuk+aaOHB7vVzvwspITjgxj7
+        DG8ArA0G/RsVPjrA8FsUQlgw66p+J8wamI/RJkWDWQXbjTooBI3BgR16OG2WMJ8dEx7m71awDzFh
+        czhZ8ozjaUx34TrksZ4+2y3iH7CX4PgFxwI8dFxNmaqG4rgTZ6Q4ozlEA6NeZexWGY0z41O79bqj
+        YcJz5jnIFHqQ7Y1+K1IIaLzJOEMOnMhEG/HAOIFKQA8rMpOZvqMUNh6aSOsN7rqa7g0nj9bY8ezJ
+        483PmetkYD9Gyx+TsYtckaApn5SRM3lUAFzELWYP4F4uhVPGcyVmIZlHQ/g2Uc7+XO+aas/UB4qq
+        /l4Rm8sJ0qa4XNO5apiqCh+Jy7ecFS4EGnHZiwFy9esCmIiftY3Gjq0U444txxL0GP0VSdlyxX0w
+        Ud1dQDvGosRcdVad19dXJQx8QhQab1cdHEV/1K3KdyUs1S3dz9ocQiKzo3EJNom3Pgn/Eame4Pl7
+        UoK6LMaYARWaqiGD7ZD1gisB7hFOg7Q7XS257ZC9gxN0YfvzhcDxqgOZvIQkgGMvrZJ/SuEF2iOb
+        bsA36Gu6Vg5MjwSuookWbnnZjhJY8E1TdLXX7/YHavf2EgBaw5lL9nv/rbTstldyj4CkvYkO+LCG
+        1xTuchjg5PvFKyJIT3WYjYaWPR8N0f1khqaz8U/L/nVClCVoQp4IvgZzepasN684Y78JXJKiCZiJ
+        0hhNKvQl5KSRNAl5mtakAlVD5jjYNaoiANeIIoDNmpQg6WOTIin+KkEE9go95KbNcshYTWrkiJMY
+        wtKghfA3SsFVyJrBZau7BOhfAbpfAYxzANjckW2iI0nCLSkW0RhZa2jaQB1hfpC99tafC3f0vapp
+        leF59TH028GdYfT6A2hfswdEnxHbYTS2LcdJOyI0GR+B4Os9PkAnimjMQrJF7nvC8MFEP+bzqSva
+        gVikTGZ/rTrLsX2/Ii2YGiIfytDGy/u6KEXQw89qErT3dMzx0tZf0Re/ie98xvHyKeG81WZQOSUV
+        oefNMoNeNwpdTkIbkmhKBNqRBHhVCGYQDIx6lbFbZTTOjE+lee1D7AiHz7s4Ko5wPhfXC6S4XsTF
+        BXBJ3QsU5jcGUOUrA7DQJ74X8inL6HOmY46qGHfafA7IxgBM6EEqelJTKJ6yxCOU5il+M9KTJOcT
+        cZZt1YAAgWHWqB6bE1HLuCDFMQAcedPnxAZQ4yBA2uxT2fl+SwseIlG04En0cn4rZXUCy8Ll/pzd
+        vHOD/dl/K1tve/zypSw392POhs+zLCRfVZWy5GucOQGVgDz32vWSiBp3Rk2NP2eqLkDKXY1bUljj
+        PDFZ6Qb+GFT0/+n7z/Stw/0eqnqBwYytIjM5B4V8i7mV8iicOTtf4SytT9iYQruJvSimEYa+gmWP
+        IEmCA0CcGl/+9/Xdk++OrFA1/+pEYPln0UvoMQ5wRb/5/PwX1zFVT5UPAAA=
+    headers:
+      access-control-allow-origin:
+      - '*'
+      cache-control:
+      - no-store, no-cache, must-revalidate
+      content-encoding:
+      - gzip
+      content-security-policy:
+      - 'default-src * data: blob: ''unsafe-eval'' ''unsafe-inline'''
+      content-type:
+      - application/json;charset=utf-8
+      date:
+      - Thu, 26 Feb 2026 15:47:25 GMT
+      expires:
+      - Thu, 19 Nov 1981 08:52:00 GMT
+      pragma:
+      - no-cache
+      server:
+      - Chuck Norris fears nothing that is not Emily.
+      set-cookie:
+      - dtsession=af8q1j3q92gttviplmb6en3rsdj2oi4r41qs61u0s5iv7papknbhuac2ik9kf85jop1qv8aeje0k7c4rfueftt7dvosnpipluu2etui;
+        expires=Sat, 28-Mar-2026 15:47:25 GMT; Max-Age=2592000; path=/; domain=.domaintools.com;
+        secure; HttpOnly
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains
+      transfer-encoding:
+      - chunked
+      vary:
+      - Accept-Encoding
+      x-time:
+      - '25688'
+    status:
+      code: 200
+      message: OK
+version: 1

pyapiary-2.1.4/src/pyapiary/tests/test_domaintools/test_integration_domaintools.py

@@ -0,0 +1,45 @@
+import os
+
+import httpx
+import pytest
+
+from pyapiary.api_connectors.domaintools import DomainToolsConnector
+from pyapiary.helpers import combine_env_configs
+
+
+def _require_domaintools_key():
+    config = combine_env_configs()
+    if not (os.getenv("DOMAINTOOLS_API_KEY") or config.get("DOMAINTOOLS_API_KEY")):
+        pytest.skip("DOMAINTOOLS_API_KEY is required for DomainTools integration tests")
+
+
+@pytest.mark.integration
+def test_domaintools_parsed_whois_vcr(vcr_cassette):
+    _require_domaintools_key()
+
+    with vcr_cassette.use_cassette("test_domaintools_parsed_whois_vcr"):
+        connector = DomainToolsConnector(load_env_vars=True, enable_logging=True)
+        try:
+            result = connector.parsed_whois("domaintools.com")
+        except httpx.ConnectError as exc:
+            pytest.skip(f"Network/DNS unavailable for DomainTools cassette recording: {exc}")
+
+        assert isinstance(result, httpx.Response)
+        assert result.status_code == 200
+        assert isinstance(result.json(), dict)
+
+
+@pytest.mark.integration
+def test_domaintools_iris_investigate_vcr(vcr_cassette):
+    _require_domaintools_key()
+
+    with vcr_cassette.use_cassette("test_domaintools_iris_investigate_vcr"):
+        connector = DomainToolsConnector(load_env_vars=True, enable_logging=True)
+        try:
+            result = connector.iris_investigate(domain="domaintools.com")
+        except httpx.ConnectError as exc:
+            pytest.skip(f"Network/DNS unavailable for DomainTools cassette recording: {exc}")
+
+        assert isinstance(result, httpx.Response)
+        assert result.status_code == 200
+        assert isinstance(result.json(), dict)

pyapiary-2.1.4/src/pyapiary/tests/test_domaintools/test_unit_async_domaintools.py

@@ -0,0 +1,80 @@
+import httpx
+import pytest
+from unittest.mock import AsyncMock, patch
+
+from pyapiary.api_connectors.domaintools import AsyncDomainToolsConnector
+
+
+@pytest.mark.asyncio
+async def test_async_init_with_api_key():
+    connector = AsyncDomainToolsConnector(api_key="test_key")
+    assert connector.api_key == "test_key"
+    assert connector.headers["X-API-KEY"] == "test_key"
+    await connector.session.aclose()
+
+
+@pytest.mark.asyncio
+async def test_async_init_with_env_key():
+    with patch.dict("os.environ", {"DOMAINTOOLS_API_KEY": "env_key"}, clear=True):
+        connector = AsyncDomainToolsConnector(load_env_vars=True)
+        assert connector.api_key == "env_key"
+        assert connector.headers["X-API-KEY"] == "env_key"
+        await connector.session.aclose()
+
+
+@pytest.mark.asyncio
+async def test_async_init_missing_key():
+    with patch.dict("os.environ", {}, clear=True):
+        with pytest.raises(ValueError, match="API key is required for DomainTools"):
+            AsyncDomainToolsConnector()
+
+
+@patch("pyapiary.api_connectors.domaintools.AsyncDomainToolsConnector.get", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_parsed_whois(mock_get):
+    request = httpx.Request("GET", "https://api.domaintools.com/v1/example.com/whois/parsed")
+    mock_get.return_value = httpx.Response(200, request=request, json={"ok": True})
+
+    connector = AsyncDomainToolsConnector(api_key="test_key")
+    result = await connector.parsed_whois("example.com")
+
+    mock_get.assert_awaited_once_with("v1/example.com/whois/parsed")
+    assert isinstance(result, httpx.Response)
+    await connector.session.aclose()
+
+
+@patch("pyapiary.api_connectors.domaintools.AsyncDomainToolsConnector.get", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_iris_investigate_valid_params(mock_get):
+    request = httpx.Request("GET", "https://api.domaintools.com/v1/iris-investigate")
+    mock_get.return_value = httpx.Response(200, request=request, json={"records": []})
+
+    connector = AsyncDomainToolsConnector(api_key="test_key")
+    result = await connector.iris_investigate(domain="domaintools.com", active="true")
+
+    mock_get.assert_awaited_once_with(
+        "/v1/iris-investigate",
+        params={"domain": "domaintools.com", "active": "true"},
+    )
+    assert isinstance(result, httpx.Response)
+    await connector.session.aclose()
+
+
+@pytest.mark.asyncio
+async def test_async_iris_investigate_requires_at_least_one_param():
+    connector = AsyncDomainToolsConnector(api_key="test_key")
+
+    with pytest.raises(ValueError, match="At least one Iris Investigate parameter is required"):
+        await connector.iris_investigate()
+
+    await connector.session.aclose()
+
+
+@pytest.mark.asyncio
+async def test_async_iris_investigate_rejects_invalid_param():
+    connector = AsyncDomainToolsConnector(api_key="test_key")
+
+    with pytest.raises(ValueError, match="Invalid Iris Investigate parameters"):
+        await connector.iris_investigate(not_a_real_param="value")
+
+    await connector.session.aclose()

pyapiary-2.1.4/src/pyapiary/tests/test_domaintools/test_unit_domaintools.py

@@ -0,0 +1,91 @@
+import httpx
+import pytest
+from unittest.mock import patch
+
+from pyapiary.api_connectors.domaintools import DomainToolsConnector
+
+
+def test_init_with_api_key():
+    connector = DomainToolsConnector(api_key="test_key")
+    assert connector.api_key == "test_key"
+    assert connector.headers["X-API-KEY"] == "test_key"
+
+
+def test_init_with_env_key():
+    with patch.dict("os.environ", {"DOMAINTOOLS_API_KEY": "env_key"}, clear=True):
+        connector = DomainToolsConnector(load_env_vars=True)
+        assert connector.api_key == "env_key"
+        assert connector.headers["X-API-KEY"] == "env_key"
+
+
+def test_init_missing_key():
+    with patch.dict("os.environ", {}, clear=True):
+        with pytest.raises(ValueError, match="API key is required for DomainTools"):
+            DomainToolsConnector()
+
+
+@patch("pyapiary.api_connectors.domaintools.DomainToolsConnector.get")
+def test_parsed_whois(mock_get):
+    request = httpx.Request("GET", "https://api.domaintools.com/v1/example.com/whois/parsed")
+    mock_get.return_value = httpx.Response(200, request=request, json={"ok": True})
+
+    connector = DomainToolsConnector(api_key="test_key")
+    result = connector.parsed_whois("example.com")
+
+    mock_get.assert_called_once_with("v1/example.com/whois/parsed")
+    assert isinstance(result, httpx.Response)
+    assert result.json() == {"ok": True}
+
+
+@patch("pyapiary.api_connectors.domaintools.DomainToolsConnector.get")
+def test_reverse_ip(mock_get):
+    request = httpx.Request("GET", "https://api.domaintools.com/v1/8.8.8.8/reverse-ip")
+    mock_get.return_value = httpx.Response(200, request=request, json={"ok": True})
+
+    connector = DomainToolsConnector(api_key="test_key")
+    result = connector.reverse_ip("8.8.8.8", exclude_total_count=True)
+
+    mock_get.assert_called_once_with("v1/8.8.8.8/reverse-ip", exclude_total_count=True)
+    assert isinstance(result, httpx.Response)
+
+
+@patch("pyapiary.api_connectors.domaintools.DomainToolsConnector.get")
+def test_reverse_nameserver(mock_get):
+    request = httpx.Request("GET", "https://api.domaintools.com/v1/ns1.example.com/name-server-domains")
+    mock_get.return_value = httpx.Response(200, request=request, json={"ok": True})
+
+    connector = DomainToolsConnector(api_key="test_key")
+    result = connector.reverse_nameserver("ns1.example.com")
+
+    mock_get.assert_called_once_with("v1/ns1.example.com/name-server-domains")
+    assert isinstance(result, httpx.Response)
+
+
+@patch("pyapiary.api_connectors.domaintools.DomainToolsConnector.get")
+def test_iris_investigate_valid_params(mock_get):
+    request = httpx.Request("GET", "https://api.domaintools.com/v1/iris-investigate")
+    mock_get.return_value = httpx.Response(200, request=request, json={"records": []})
+
+    connector = DomainToolsConnector(api_key="test_key")
+    result = connector.iris_investigate(domain="domaintools.com", active="true")
+
+    mock_get.assert_called_once_with(
+        "/v1/iris-investigate",
+        params={"domain": "domaintools.com", "active": "true"},
+    )
+    assert isinstance(result, httpx.Response)
+    assert result.json() == {"records": []}
+
+
+def test_iris_investigate_requires_at_least_one_param():
+    connector = DomainToolsConnector(api_key="test_key")
+
+    with pytest.raises(ValueError, match="At least one Iris Investigate parameter is required"):
+        connector.iris_investigate()
+
+
+def test_iris_investigate_rejects_invalid_param():
+    connector = DomainToolsConnector(api_key="test_key")
+
+    with pytest.raises(ValueError, match="Invalid Iris Investigate parameters"):
+        connector.iris_investigate(not_a_real_param="value")