domaintools-api 2.0.0__tar.gz → 2.2.0__tar.gz

{domaintools_api-2.0.0/domaintools_api.egg-info → domaintools_api-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: domaintools_api
-Version: 2.0.0
+Version: 2.2.0
 Summary: DomainTools Official Python API
 Author-email: DomainTools <integrations@domaintools.com>
 License: The MIT License (MIT)
@@ -33,16 +33,11 @@ Classifier: Natural Language :: English
 Classifier: Environment :: Console
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx

domaintools_api-2.2.0/VERSION

@@ -0,0 +1 @@
+2.2.0

{domaintools_api-2.0.0 → domaintools_api-2.2.0}/domaintools/_version.py

@@ -20,4 +20,4 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 """
 
-current = "2.0.0"
+current = "2.2.0"

{domaintools_api-2.0.0 → domaintools_api-2.2.0}/domaintools/api.py

@@ -1,11 +1,16 @@
 from datetime import datetime, timedelta, timezone
 from hashlib import sha1, sha256, md5
 from hmac import new as hmac
-from types import MethodType
 import re
 
 from domaintools._version import current as version
-from domaintools.results import GroupedIterable, ParsedWhois, Reputation, Results
+from domaintools.results import (
+    GroupedIterable,
+    ParsedWhois,
+    ParsedDomainRdap,
+    Reputation,
+    Results,
+)
 from domaintools.filters import (
     filter_by_riskscore,
     filter_by_expire_date,
@@ -51,7 +56,7 @@ class API(object):
         verify_ssl=True,
         rate_limit=True,
         proxy_url=None,
-        always_sign_api_key=False,
+        always_sign_api_key=True,
         key_sign_hash="sha256",
         app_name="python_wrapper",
         app_version=version,
@@ -78,16 +83,12 @@ class API(object):
         self._build_api_url(api_url, api_port)
 
         if not https:
-            raise Exception(
-                "The DomainTools API endpoints no longer support http traffic. Please make sure https=True."
-            )
+            raise Exception("The DomainTools API endpoints no longer support http traffic. Please make sure https=True.")
         if proxy_url:
             if isinstance(proxy_url, str):
                 self.proxy_url = {"http://": proxy_url, "https://": proxy_url}
             else:
-                raise Exception(
-                    "Proxy URL must be a string. For example: '127.0.0.1:8888'"
-                )
+                raise Exception("Proxy URL must be a string. For example: '127.0.0.1:8888'")
 
     def _build_api_url(self, api_url=None, api_port=None):
         """Build the API url based on the given url and port. Defaults to `https://api.domaintools.com`"""
@@ -111,31 +112,18 @@ class API(object):
             hours = limit_hours and 3600 / float(limit_hours)
             minutes = limit_minutes and 60 / float(limit_minutes)
 
-            self.limits[product["id"]] = {
-                "interval": timedelta(seconds=minutes or hours or default)
-            }
+            self.limits[product["id"]] = {"interval": timedelta(seconds=minutes or hours or default)}
 
     def _results(self, product, path, cls=Results, **kwargs):
         """Returns _results for the specified API path with the specified **kwargs parameters"""
-        if (
-            product != "account-information"
-            and self.rate_limit
-            and not self.limits_set
-            and not self.limits
-        ):
+        if product != "account-information" and self.rate_limit and not self.limits_set and not self.limits:
             self._rate_limit()
 
         uri = "/".join((self._rest_api_url, path.lstrip("/")))
         parameters = self.default_parameters.copy()
         parameters["api_username"] = self.username
         self.handle_api_key(path, parameters)
-        parameters.update(
-            {
-                key: str(value).lower() if value in (True, False) else value
-                for key, value in kwargs.items()
-                if value is not None
-            }
-        )
+        parameters.update({key: str(value).lower() if value in (True, False) else value for key, value in kwargs.items() if value is not None})
 
         return cls(self, product, uri, **parameters)
 
@@ -148,14 +136,10 @@ class API(object):
             else:
                 raise ValueError(
                     "Invalid value '{0}' for 'key_sign_hash'. "
-                    "Values available are {1}".format(
-                        self.key_sign_hash, ",".join(AVAILABLE_KEY_SIGN_HASHES)
-                    )
+                    "Values available are {1}".format(self.key_sign_hash, ",".join(AVAILABLE_KEY_SIGN_HASHES))
                 )
 
-            parameters["timestamp"] = datetime.now(timezone.utc).strftime(
-                "%Y-%m-%dT%H:%M:%SZ"
-            )
+            parameters["timestamp"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
             parameters["signature"] = hmac(
                 self.key.encode("utf8"),
                 "".join([self.username, parameters["timestamp"], path]).encode("utf8"),
@@ -164,9 +148,7 @@ class API(object):
 
     def account_information(self, **kwargs):
         """Provides a snapshot of your accounts current API usage"""
-        return self._results(
-            "account-information", "/v1/account", items_path=("products",), **kwargs
-        )
+        return self._results("account-information", "/v1/account", items_path=("products",), **kwargs)
 
     def available_api_calls(self):
         """Provides a list of api calls that you can use based on your account information."""
@@ -181,25 +163,10 @@ class API(object):
                 string[1:],
             )
 
-        api_calls = tuple(
-            (
-                api_call
-                for api_call in dir(API)
-                if not api_call.startswith("_")
-                and callable(getattr(API, api_call, None))
-            )
-        )
-        return sorted(
-            [
-                snakecase(p["id"])
-                for p in self.account_information()["products"]
-                if snakecase(p["id"]) in api_calls
-            ]
-        )
+        api_calls = tuple((api_call for api_call in dir(API) if not api_call.startswith("_") and callable(getattr(API, api_call, None))))
+        return sorted([snakecase(p["id"]) for p in self.account_information()["products"] if snakecase(p["id"]) in api_calls])
 
-    def brand_monitor(
-        self, query, exclude=None, domain_status=None, days_back=None, **kwargs
-    ):
+    def brand_monitor(self, query, exclude=None, domain_status=None, days_back=None, **kwargs):
         """Pass in one or more terms as a list or separated by the pipe character ( | )"""
         if exclude is None:
             exclude = []
@@ -325,9 +292,16 @@ class API(object):
             **kwargs,
         )
 
-    def registrant_monitor(
-        self, query, exclude=None, days_back=0, limit=None, **kwargs
-    ):
+    def parsed_domain_rdap(self, query, **kwargs):
+        """Pass in a domain name to see the most recent Domain-RDAP registration record"""
+        return self._results(
+            "parsed-domain-rdap",
+            "/v1/{0}/rdap/parsed/".format(query),
+            cls=ParsedDomainRdap,
+            **kwargs,
+        )
+
+    def registrant_monitor(self, query, exclude=None, days_back=0, limit=None, **kwargs):
         """One or more terms as a Python list or separated by the pipe character ( | )."""
         if exclude is None:
             exclude = []
@@ -355,15 +329,11 @@ class API(object):
 
     def reverse_ip(self, domain=None, limit=None, **kwargs):
         """Pass in a domain name."""
-        return self._results(
-            "reverse-ip", "/v1/{0}/reverse-ip".format(domain), limit=limit, **kwargs
-        )
+        return self._results("reverse-ip", "/v1/{0}/reverse-ip".format(domain), limit=limit, **kwargs)
 
     def host_domains(self, ip=None, limit=None, **kwargs):
         """Pass in an IP address."""
-        return self._results(
-            "reverse-ip", "/v1/{0}/host-domains".format(ip), limit=limit, **kwargs
-        )
+        return self._results("reverse-ip", "/v1/{0}/host-domains".format(ip), limit=limit, **kwargs)
 
     def reverse_ip_whois(
         self,
@@ -402,9 +372,7 @@ class API(object):
             **kwargs,
         )
 
-    def reverse_whois(
-        self, query, exclude=None, scope="current", mode="purchase", **kwargs
-    ):
+    def reverse_whois(self, query, exclude=None, scope="current", mode="purchase", **kwargs):
         """List of one or more terms to search for in the Whois record,
         as a Python list or separated with the pipe character ( | ).
         """
@@ -424,9 +392,7 @@ class API(object):
         """Pass in a domain name or an IP address to perform a whois lookup."""
         return self._results("whois", "/v1/{0}/whois".format(query), **kwargs)
 
-    def whois_history(
-        self, query, mode=None, sort=None, offset=None, limit=None, **kwargs
-    ):
+    def whois_history(self, query, mode=None, sort=None, offset=None, limit=None, **kwargs):
         """Pass in a domain name."""
         return self._results(
             "whois-history",
@@ -485,16 +451,7 @@ class API(object):
         """Performs a search for the provided search terms ANDed together,
         returning the pivot engine row data for the resulting domains.
         """
-        if (
-            not domain
-            and not ip
-            and not email
-            and not nameserver
-            and not registrar
-            and not registrant
-            and not registrant_org
-            and not kwargs
-        ):
+        if not domain and not ip and not email and not nameserver and not registrar and not registrant and not registrant_org and not kwargs:
             raise ValueError("At least one search term must be specified")
 
         return self._results(
@@ -569,12 +526,8 @@ class API(object):
         younger_than_date = kwargs.pop("younger_than_date", {}) or None
         older_than_date = kwargs.pop("older_than_date", {}) or None
         updated_after = kwargs.pop("updated_after", {}) or None
-        include_domains_with_missing_field = (
-            kwargs.pop("include_domains_with_missing_field", {}) or None
-        )
-        exclude_domains_with_missing_field = (
-            kwargs.pop("exclude_domains_with_missing_field", {}) or None
-        )
+        include_domains_with_missing_field = kwargs.pop("include_domains_with_missing_field", {}) or None
+        exclude_domains_with_missing_field = kwargs.pop("exclude_domains_with_missing_field", {}) or None
 
         filtered_results = DTResultFilter(result_set=results).by(
             [
@@ -582,12 +535,8 @@ class API(object):
                 filter_by_expire_date(date=younger_than_date, lookup_type="before"),
                 filter_by_expire_date(date=older_than_date, lookup_type="after"),
                 filter_by_date_updated_after(date=updated_after),
-                filter_by_field(
-                    field=include_domains_with_missing_field, filter_type="include"
-                ),
-                filter_by_field(
-                    field=exclude_domains_with_missing_field, filter_type="exclude"
-                ),
+                filter_by_field(field=include_domains_with_missing_field, filter_type="include"),
+                filter_by_field(field=exclude_domains_with_missing_field, filter_type="exclude"),
             ]
         )
 
@@ -692,9 +641,7 @@ class API(object):
             kwargs["search_hash"] = search_hash
 
         if not (kwargs or domains):
-            raise ValueError(
-                "Need to define investigation using kwarg filters or domains"
-            )
+            raise ValueError("Need to define investigation using kwarg filters or domains")
 
         if isinstance(domains, (list, tuple)):
             domains = ",".join(domains)
@@ -724,12 +671,8 @@ class API(object):
                 filter_by_expire_date(date=younger_than_date, lookup_type="before"),
                 filter_by_expire_date(date=older_than_date, lookup_type="after"),
                 filter_by_date_updated_after(date=updated_after),
-                filter_by_field(
-                    field=include_domains_with_missing_field, filter_type="include"
-                ),
-                filter_by_field(
-                    field=exclude_domains_with_missing_field, filter_type="exclude"
-                ),
+                filter_by_field(field=include_domains_with_missing_field, filter_type="include"),
+                filter_by_field(field=exclude_domains_with_missing_field, filter_type="exclude"),
             ]
         )
 
@@ -769,9 +712,7 @@ class API(object):
 
         if include_counts:
             if not datetime_counts_since:
-                raise ValueError(
-                    "Need to define datetime_counts_since when include_counts is True"
-                )
+                raise ValueError("Need to define datetime_counts_since when include_counts is True")
             if isinstance(datetime_counts_since, datetime):
                 datetime_counts_since = str(datetime_counts_since.astimezone())
             elif isinstance(datetime_counts_since, str):
@@ -979,9 +920,7 @@ class API(object):
             **kwargs,
         )
 
-    def iris_detect_manage_watchlist_domains(
-        self, watchlist_domain_ids, state, **kwargs
-    ):
+    def iris_detect_manage_watchlist_domains(self, watchlist_domain_ids, state, **kwargs):
         """Changes the watch state of a list of domains by their Iris Detect domain ID.
 
         watchlist_domain_ids: List[str]: required. List of Iris Detect domain IDs to manage.
@@ -1000,9 +939,7 @@ class API(object):
             **kwargs,
         )
 
-    def iris_detect_escalate_domains(
-        self, watchlist_domain_ids, escalation_type, **kwargs
-    ):
+    def iris_detect_escalate_domains(self, watchlist_domain_ids, escalation_type, **kwargs):
         """Changes the escalation type of a list of domains by their Iris Detect domain ID.
 
         watchlist_domain_ids: List[str]: required. List of Iris Detect domain IDs to escalate.
@@ -1120,3 +1057,31 @@ class API(object):
             response_path=(),
             **kwargs,
         )
+
+    def nod(self, **kwargs):
+        """Returns back list of the newly observed domains feed"""
+        sessionID = kwargs.get("sessionID")
+        after = kwargs.get("after")
+        if not (sessionID or after):
+            raise ValueError("sessionID or after (can be both) must be defined")
+
+        return self._results(
+            "newly-observed-domains-feed-(api)",
+            "v1/feed/nod/",
+            response_path=(),
+            **kwargs,
+        )
+
+    def nad(self, **kwargs):
+        """Returns back list of the newly active domains feed"""
+        sessionID = kwargs.get("sessionID")
+        after = kwargs.get("after")
+        if not (sessionID or after):
+            raise ValueError("sessionID or after (can be both) must be defined")
+
+        return self._results(
+            "newly-active-domains-feed-(api)",
+            "v1/feed/nad/",
+            response_path=(),
+            **kwargs,
+        )

{domaintools_api-2.0.0 → domaintools_api-2.2.0}/domaintools/base_results.py

@@ -1,27 +1,46 @@
 """Defines the base result object - which specifies how DomainTools API endpoints will be interacted with"""
-import collections
+
 import json
 import re
 import time
 import logging
 from datetime import datetime
 
-from domaintools.exceptions import (BadRequestException, InternalServerErrorException, NotAuthorizedException,
-                                    NotFoundException, ServiceException, ServiceUnavailableException,
-                                    IncompleteResponseException, RequestUriTooLongException)
+from domaintools.exceptions import (
+    BadRequestException,
+    InternalServerErrorException,
+    NotAuthorizedException,
+    NotFoundException,
+    ServiceException,
+    ServiceUnavailableException,
+    IncompleteResponseException,
+    RequestUriTooLongException,
+)
+from domaintools.utils import get_feeds_products_list
+
 from httpx import Client
 
-try: # pragma: no cover
+try:  # pragma: no cover
     from collections.abc import MutableMapping, MutableSequence
-except ImportError: # pragma: no cover
+except ImportError:  # pragma: no cover
     from collections import MutableMapping, MutableSequence
 
 log = logging.getLogger(__name__)
 
+
 class Results(MutableMapping, MutableSequence):
     """The base (abstract) DomainTools result definition"""
 
-    def __init__(self, api, product, url, items_path=(), response_path=('response', ), proxy_url=None, **kwargs):
+    def __init__(
+        self,
+        api,
+        product,
+        url,
+        items_path=(),
+        response_path=("response",),
+        proxy_url=None,
+        **kwargs,
+    ):
         self.api = api
         self.product = product
         self.url = url
@@ -41,29 +60,33 @@ class Results(MutableMapping, MutableSequence):
 
         now = datetime.now()
         limit = self.api.limits[self.product]
-        if 'last_scheduled' not in limit:
-            limit['last_scheduled'] = now
+        if "last_scheduled" not in limit:
+            limit["last_scheduled"] = now
             return None
 
-        safe_after = limit['last_scheduled'] + limit['interval']
+        safe_after = limit["last_scheduled"] + limit["interval"]
         wait_for = 0
         if now < safe_after:
             wait_for = safe_after - now
             wait_for = float(wait_for.seconds) + (float(wait_for.microseconds) / 1000000.0)
-            limit['last_scheduled'] = safe_after
+            limit["last_scheduled"] = safe_after
         else:
-            limit['last_scheduled'] = now
+            limit["last_scheduled"] = now
 
         return wait_for
 
     def _make_request(self):
 
-        with Client(verify=self.api.verify_ssl, proxies=self.api.proxy_url, timeout=None) as session:
-            if self.product in ['iris-investigate', 'iris-enrich', 'iris-detect-escalate-domains']:
+        with Client(verify=self.api.verify_ssl, proxy=self.api.proxy_url, timeout=None) as session:
+            if self.product in [
+                "iris-investigate",
+                "iris-enrich",
+                "iris-detect-escalate-domains",
+            ]:
                 post_data = self.kwargs.copy()
                 post_data.update(self.api.extra_request_params)
                 return session.post(url=self.url, data=post_data)
-            elif self.product in ['iris-detect-manage-watchlist-domains']:
+            elif self.product in ["iris-detect-manage-watchlist-domains"]:
                 patch_data = self.kwargs.copy()
                 patch_data.update(self.api.extra_request_params)
                 return session.patch(url=self.url, json=patch_data)
@@ -72,20 +95,22 @@ class Results(MutableMapping, MutableSequence):
 
     def _get_results(self):
         wait_for = self._wait_time()
-        if self.api.rate_limit and (wait_for is None or self.product == 'account-information'):
+        if self.api.rate_limit and (wait_for is None or self.product == "account-information"):
             data = self._make_request()
-            if data.status_code == 503: # pragma: no cover
+            if data.status_code == 503:  # pragma: no cover
                 sleeptime = 60
-                log.info('503 encountered for [%s] - sleeping [%s] seconds before retrying request.',
-                         self.product, sleeptime)
+                log.info(
+                    "503 encountered for [%s] - sleeping [%s] seconds before retrying request.",
+                    self.product,
+                    sleeptime,
+                )
                 time.sleep(sleeptime)
                 self._wait_time()
                 data = self._make_request()
             return data
 
         if wait_for > 0:
-            log.info('Sleeping for [%s] prior to requesting [%s].',
-                     wait_for, self.product)
+            log.info("Sleeping for [%s] prior to requesting [%s].", wait_for, self.product)
             time.sleep(wait_for)
         return self._make_request()
 
@@ -93,7 +118,11 @@ class Results(MutableMapping, MutableSequence):
         if self._data is None:
             results = self._get_results()
             self.setStatus(results.status_code, results)
-            if self.kwargs.get('format', 'json') == 'json':
+            if (
+                self.kwargs.get("format", "json") == "json"
+                and self.product
+                not in get_feeds_products_list()  # Special handling of feeds products' data to preserve the result in jsonline format
+            ):
                 self._data = results.json()
             else:
                 self._data = results.text
@@ -109,11 +138,9 @@ class Results(MutableMapping, MutableSequence):
             return self._data
 
     def check_limit_exceeded(self):
-        if self.kwargs.get('format', 'json') == 'json':
-            if ("response" in self._data and
-                "limit_exceeded" in self._data['response'] and
-                self._data['response']['limit_exceeded'] is True):
-                return True, self._data['response']['message']
+        if self.kwargs.get("format", "json") == "json":
+            if "response" in self._data and "limit_exceeded" in self._data["response"] and self._data["response"]["limit_exceeded"] is True:
+                return True, self._data["response"]["message"]
         # TODO: handle html, xml response errors better.
         elif "response" in self._data and "limit_exceeded" in self._data:
             return True, "limit exceeded"
@@ -121,7 +148,7 @@ class Results(MutableMapping, MutableSequence):
 
     @property
     def status(self):
-        if not getattr(self, '_status', None):
+        if not getattr(self, "_status", None):
             self._status = self._get_results().status_code
 
         return self._status
@@ -135,7 +162,7 @@ class Results(MutableMapping, MutableSequence):
         if response is not None:
             try:
                 reason = response.json()
-            except Exception: # pragma: no cover
+            except Exception:  # pragma: no cover
                 reason = response.text
                 if callable(reason):
                     reason = reason()
@@ -146,16 +173,16 @@ class Results(MutableMapping, MutableSequence):
             raise NotAuthorizedException(code, reason)
         elif code == 404:
             raise NotFoundException(code, reason)
-        elif code == 500: # pragma: no cover
+        elif code == 500:  # pragma: no cover
             raise InternalServerErrorException(code, reason)
-        elif code == 503: # pragma: no cover
+        elif code == 503:  # pragma: no cover
             raise ServiceUnavailableException(code, reason)
-        elif code == 206: # pragma: no cover
+        elif code == 206:  # pragma: no cover
             raise IncompleteResponseException(code, reason)
-        elif code == 414: # pragma: no cover
+        elif code == 414:  # pragma: no cover
             raise RequestUriTooLongException(code, reason)
-        else: # pragma: no cover
-            raise ServiceException(code, 'Unknown Exception')
+        else:  # pragma: no cover
+            raise ServiceException(code, "Unknown Exception")
 
     def response(self):
         if self._response is None:
@@ -171,7 +198,7 @@ class Results(MutableMapping, MutableSequence):
 
     def emails(self):
         """Find and returns all emails mentioned in the response"""
-        return set(re.findall(r'[\w\.-]+@[\w\.-]+', str(self.response())))
+        return set(re.findall(r"[\w\.-]+@[\w\.-]+", str(self.response())))
 
     def _items(self):
         if self._items_list is None:
@@ -221,25 +248,45 @@ class Results(MutableMapping, MutableSequence):
 
     @property
     def json(self):
-        self.kwargs.pop('format', None)
-        return self.__class__(format='json', product=self.product, url=self.url, items_path=self.items_path,
-                              response_path=self.response_path, api=self.api, **self.kwargs)
+        self.kwargs.pop("format", None)
+        return self.__class__(
+            format="json",
+            product=self.product,
+            url=self.url,
+            items_path=self.items_path,
+            response_path=self.response_path,
+            api=self.api,
+            **self.kwargs,
+        )
 
     @property
     def xml(self):
-        self.kwargs.pop('format', None)
-        return self.__class__(format='xml', product=self.product, url=self.url, items_path=self.items_path,
-                              response_path=self.response_path, api=self.api, **self.kwargs)
+        self.kwargs.pop("format", None)
+        return self.__class__(
+            format="xml",
+            product=self.product,
+            url=self.url,
+            items_path=self.items_path,
+            response_path=self.response_path,
+            api=self.api,
+            **self.kwargs,
+        )
 
     @property
     def html(self):
-        self.kwargs.pop('format', None)
-        return self.__class__(api=self.api, product=self.product, url=self.url, items_path=self.items_path,
-                              response_path=self.response_path, format='html', **self.kwargs)
+        self.kwargs.pop("format", None)
+        return self.__class__(
+            api=self.api,
+            product=self.product,
+            url=self.url,
+            items_path=self.items_path,
+            response_path=self.response_path,
+            format="html",
+            **self.kwargs,
+        )
 
     def as_list(self):
-        return '\n'.join([json.dumps(item, indent=4, separators=(',', ': ')) for item in self._items()])
+        return "\n".join([json.dumps(item, indent=4, separators=(",", ": ")) for item in self._items()])
 
     def __str__(self):
-        return str(json.dumps(self.data(), indent=4,
-                              separators=(',', ': ')) if self.kwargs.get('format', 'json') == 'json' else self.data())
+        return str(json.dumps(self.data(), indent=4, separators=(",", ": ")) if self.kwargs.get("format", "json") == "json" else self.data())

{domaintools_api-2.0.0 → domaintools_api-2.2.0}/domaintools/cli/api.py

@@ -148,10 +148,11 @@ class DTCLICommand:
             kwargs (Optional[Dict], optional): The command available kwargs to pass in domaintools API
         """
         try:
-            rate_limit = params.pop("rate_limit") or False
-            response_format = params.pop("format") or "json"
-            out_file = params.pop("out_file") or sys.stdout
-            verify_ssl = params.pop("no_verify_ssl") or False
+            rate_limit = params.pop("rate_limit", False)
+            response_format = params.pop("format", "json")
+            out_file = params.pop("out_file", sys.stdout)
+            verify_ssl = params.pop("no_verify_ssl", False)
+            always_sign_api_key = params.pop("no_sign_api_key", False)
             source = None
 
             if "src_file" in params:
@@ -185,6 +186,7 @@ class DTCLICommand:
                     app_name=cls.APP_PARTNER_NAME,
                     verify_ssl=verify_ssl,
                     rate_limit=rate_limit,
+                    always_sign_api_key=always_sign_api_key,
                 )
                 dt_api_func = getattr(dt_api, name)
 

{domaintools_api-2.0.0 → domaintools_api-2.2.0}/domaintools/cli/commands/__init__.py

@@ -4,3 +4,4 @@ from .domains import *
 from .ips import *
 from .phisheye import *
 from .detects import *
+from .feeds import *