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

{domaintools_api-2.1.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.1.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.1.0 → domaintools_api-2.2.0}/domaintools/_version.py

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

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

@@ -4,7 +4,13 @@ from hmac import new as hmac
 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,
@@ -77,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`"""
@@ -110,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)
 
@@ -147,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"),
@@ -163,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."""
@@ -180,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 = []
@@ -324,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 = []
@@ -354,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,
@@ -401,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 ( | ).
         """
@@ -423,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",
@@ -484,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(
@@ -568,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(
             [
@@ -581,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"),
             ]
         )
 
@@ -691,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)
@@ -723,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"),
             ]
         )
 
@@ -768,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):
@@ -978,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.
@@ -999,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.

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

@@ -68,9 +68,7 @@ class Results(MutableMapping, MutableSequence):
         wait_for = 0
         if now < safe_after:
             wait_for = safe_after - now
-            wait_for = float(wait_for.seconds) + (
-                float(wait_for.microseconds) / 1000000.0
-            )
+            wait_for = float(wait_for.seconds) + (float(wait_for.microseconds) / 1000000.0)
             limit["last_scheduled"] = safe_after
         else:
             limit["last_scheduled"] = now
@@ -79,9 +77,7 @@ class Results(MutableMapping, MutableSequence):
 
     def _make_request(self):
 
-        with Client(
-            verify=self.api.verify_ssl, proxies=self.api.proxy_url, timeout=None
-        ) as session:
+        with Client(verify=self.api.verify_ssl, proxy=self.api.proxy_url, timeout=None) as session:
             if self.product in [
                 "iris-investigate",
                 "iris-enrich",
@@ -95,15 +91,11 @@ class Results(MutableMapping, MutableSequence):
                 patch_data.update(self.api.extra_request_params)
                 return session.patch(url=self.url, json=patch_data)
             else:
-                return session.get(
-                    url=self.url, params=self.kwargs, **self.api.extra_request_params
-                )
+                return session.get(url=self.url, params=self.kwargs, **self.api.extra_request_params)
 
     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
                 sleeptime = 60
@@ -118,9 +110,7 @@ class Results(MutableMapping, MutableSequence):
             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()
 
@@ -143,19 +133,13 @@ class Results(MutableMapping, MutableSequence):
                 self._limit_exceeded_message = message
 
         if self._limit_exceeded is True:
-            raise ServiceException(
-                503, "Limit Exceeded{}".format(self._limit_exceeded_message)
-            )
+            raise ServiceException(503, "Limit Exceeded{}".format(self._limit_exceeded_message))
         else:
             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
-            ):
+            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:
@@ -302,16 +286,7 @@ class Results(MutableMapping, MutableSequence):
         )
 
     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.1.0 → domaintools_api-2.2.0}/domaintools/cli/commands/domains.py

@@ -16,9 +16,7 @@ def brand_monitor(
     ctx: typer.Context,
     query: str = typer.Option(..., "-q", "--query", help="The query to use."),
     exclude: str = typer.Option(None, "--exclude", help="The exclude condition."),
-    domain_status: str = typer.Option(
-        None, "--domain-status", help="The domain status."
-    ),
+    domain_status: str = typer.Option(None, "--domain-status", help="The domain status."),
     days_back: int = typer.Option(None, "--days-back", help="The days back to check."),
     user: str = typer.Option(None, "-u", "--user", help="Domaintools API Username."),
     key: str = typer.Option(None, "-k", "--key", help="DomainTools API key"),
@@ -41,9 +39,7 @@ def brand_monitor(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -81,9 +77,7 @@ def domain_profile(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -100,19 +94,13 @@ def domain_profile(
 def domain_search(
     ctx: typer.Context,
     query: str = typer.Option(..., "-q", "--query", help="The domain name to query."),
-    exclude_query: str = typer.Option(
-        None, "--exclude-query", help="The exclusion filter to query."
-    ),
+    exclude_query: str = typer.Option(None, "--exclude-query", help="The exclusion filter to query."),
     max_length: int = typer.Option(25, "--max-length", help="The max length"),
     min_length: int = typer.Option(2, "--min-length", help="The min length"),
     has_hyphen: bool = typer.Option(True, "--has-hyphen", help=""),
     has_number: bool = typer.Option(True, "--has-number", help=""),
-    active_only: bool = typer.Option(
-        False, "--active-only", help="Search for active only domains."
-    ),
-    deleted_only: bool = typer.Option(
-        False, "--deleted-only", help="Search for deleted only domains."
-    ),
+    active_only: bool = typer.Option(False, "--active-only", help="Search for active only domains."),
+    deleted_only: bool = typer.Option(False, "--deleted-only", help="Search for deleted only domains."),
     anchor_left: bool = typer.Option(False, "--achor-left", help=""),
     anchor_right: bool = typer.Option(False, "--achor-right", help=""),
     page: int = typer.Option(1, "--page", help="Number of pages to return."),
@@ -137,9 +125,7 @@ def domain_search(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -177,9 +163,7 @@ def hosting_history(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         True,
         "--no-verify-ssl",
@@ -219,9 +203,7 @@ def name_server_monitor(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -259,9 +241,7 @@ def parsed_whois(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -271,6 +251,44 @@ def parsed_whois(
     DTCLICommand.run(name=c.PARSED_WHOIS, params=ctx.params)
 
 
+@dt_cli.command(
+    name=c.PARSED_DOMAIN_RDAP,
+    help=get_cli_helptext_by_name(command_name=c.PARSED_DOMAIN_RDAP),
+)
+def parsed_domain_rdap(
+    ctx: typer.Context,
+    query: str = typer.Option(..., "-q", "--query", help="The domain to query."),
+    user: str = typer.Option(None, "-u", "--user", help="Domaintools API Username."),
+    key: str = typer.Option(None, "-k", "--key", help="DomainTools API key"),
+    creds_file: str = typer.Option(
+        "~/.dtapi",
+        "-c",
+        "--credfile",
+        help="Optional file with API username and API key, one per line.",
+    ),
+    rate_limit: bool = typer.Option(
+        False,
+        "-l",
+        "--rate-limit",
+        help="Rate limit API calls against the API based on per minute limits.",
+    ),
+    format: str = typer.Option(
+        "json",
+        "-f",
+        "--format",
+        help="Output format in {'list', 'json', 'xml', 'html'}",
+        callback=DTCLICommand.validate_format_input,
+    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
+    no_verify_ssl: bool = typer.Option(
+        False,
+        "--no-verify-ssl",
+        help="Skip verification of SSL certificate when making HTTPs API calls",
+    ),
+):
+    DTCLICommand.run(name=c.PARSED_DOMAIN_RDAP, params=ctx.params)
+
+
 @dt_cli.command(
     name=c.REGISTRANT_MONITOR,
     help=get_cli_helptext_by_name(command_name=c.REGISTRANT_MONITOR),
@@ -306,9 +324,7 @@ def registrant_monitor(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -347,9 +363,7 @@ def reputation(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -388,9 +402,7 @@ def reverse_ip(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -429,9 +441,7 @@ def reverse_nameserver(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -454,9 +464,7 @@ def reverse_whois(
         "--scope",
         help="Sets the scope of the report to include only current Whois records, or to include both current and historic records.",
     ),
-    mode: str = typer.Option(
-        "purchase", "--mode", help="Values must be purchase (the default) or quote"
-    ),
+    mode: str = typer.Option("purchase", "--mode", help="Values must be purchase (the default) or quote"),
     user: str = typer.Option(None, "-u", "--user", help="Domaintools API Username."),
     key: str = typer.Option(None, "-k", "--key", help="DomainTools API key"),
     creds_file: str = typer.Option(
@@ -478,9 +486,7 @@ def reverse_whois(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -518,9 +524,7 @@ def whois(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -552,9 +556,7 @@ def whois_history(
         "--limit",
         help="Specify the maximum number of records to retrieve in an API query.",
     ),
-    offset: int = typer.Option(
-        None, "--offset", help="For paginating requests beyond the limit."
-    ),
+    offset: int = typer.Option(None, "--offset", help="For paginating requests beyond the limit."),
     user: str = typer.Option(None, "-u", "--user", help="Domaintools API Username."),
     key: str = typer.Option(None, "-k", "--key", help="DomainTools API key"),
     creds_file: str = typer.Option(
@@ -576,9 +578,7 @@ def whois_history(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -616,9 +616,7 @@ def risk(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -656,9 +654,7 @@ def risk_evidence(
         help="Output format in {'list', 'json', 'xml', 'html'}",
         callback=DTCLICommand.validate_format_input,
     ),
-    out_file: typer.FileTextWrite = typer.Option(
-        sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"
-    ),
+    out_file: typer.FileTextWrite = typer.Option(sys.stdout, "-o", "--out-file", help="Output file (defaults to stdout)"),
     no_verify_ssl: bool = typer.Option(
         False,
         "--no-verify-ssl",
@@ -674,6 +670,7 @@ __all__ = [
     "domain_search",
     "name_server_monitor",
     "parsed_whois",
+    "parsed_domain_rdap",
     "registrant_monitor",
     "reputation",
     "reverse_ip",

{domaintools_api-2.1.0 → domaintools_api-2.2.0}/domaintools/cli/constants.py

@@ -8,6 +8,7 @@ DOMAIN_PROFILE = "domain_profile"
 DOMAIN_SEARCH = "domain_search"
 HOSTING_HISTORY = "hosting_history"
 NAME_SERVER_MONITOR = "name_server_monitor"
+PARSED_DOMAIN_RDAP = "parsed_domain_rdap"
 PARSED_WHOIS = "parsed_whois"
 REGISTRANT_MONITOR = "registrant_monitor"
 REPUTATION = "reputation"

{domaintools_api-2.1.0 → domaintools_api-2.2.0}/domaintools/cli/utils.py

@@ -60,6 +60,7 @@ _command_help_mapper = {
     c.IP_MONITOR: "Pass in the IP Address you wish to query ( i.e. 199.30.228.112 ).",
     c.IP_REGISTRANT_MONITOR: "Query based on free text query terms",
     c.NAME_SERVER_MONITOR: "Pass in the hostname of the Name Server you wish to query ( i.e. dynect.net ).",
+    c.PARSED_DOMAIN_RDAP: "Pass in a domain name to see the most recent Domain-RDAP registration record.",
     c.PARSED_WHOIS: "Pass in a domain name.",
     c.REGISTRANT_MONITOR: "One or more terms as a Python list or separated by the pipe character ( | ).",
     c.REPUTATION: "Pass in a domain name to see its reputation score.",

domaintools_api-2.2.0/domaintools/results.py

@@ -0,0 +1,143 @@
+"""Defines the used Result object based on the current versions and/or features available to Python runtime
+
+Additionally, defines any custom result objects that may be used to enable more Pythonic interaction with endpoints.
+"""
+
+from itertools import chain
+
+try:  # pragma: no cover
+    from collections import OrderedDict
+except ImportError:  # pragma: no cover
+    from ordereddict import OrderedDict
+
+from itertools import zip_longest
+from domaintools_async import AsyncResults as Results
+
+
+class Reputation(Results):
+    """Returns the reputation results in a format that can quickly be converted into floats / ints"""
+
+    def __float__(self):
+        return float(self["risk_score"])
+
+    def __int__(self):
+        return int(self["risk_score"])
+
+
+class GroupedIterable(Results):
+    """Returns a results item in a format that allows for grouped iteration of mulpitle result lists"""
+
+    def _items(self):
+        if self._items_list is None:
+            self._items_list = chain(
+                *[zip_longest([], value, fillvalue=key) for key, value in self.response().items() if type(value) in (list, tuple)]
+            )
+
+        return self._items_list
+
+
+class ParsedWhois(Results):
+    """Returns the parsed whois results in a format that can quickly be flattened"""
+
+    def flattened(self):
+        """Returns a flattened version of the parsed whois data"""
+        parsed = self["parsed_whois"]
+        flat = OrderedDict()
+        for key in ("domain", "created_date", "updated_date", "expired_date", "statuses", "name_servers"):
+            if key in parsed:
+                value = parsed[key]
+                flat[key] = " | ".join(value) if type(value) in (list, tuple) else value
+
+        registrar = parsed.get("registrar", {})
+        for key in ("name", "abuse_contact_phone", "abuse_contact_email", "iana_id", "url", "whois_server"):
+            if key in registrar:
+                flat["registrar_{0}".format(key)] = registrar[key]
+
+        if "networks" in parsed:
+            networks = parsed.get("networks")
+            for network in networks:
+                id = network.get("id")
+                for key in ("range", "asn", "org", "parent", "customer", "country", "phone", "status", "source", "updated_date", "created_date"):
+                    if key in network:
+                        value = network[key]
+                        flat["network_{0}".format(id)] = " ".join(value) if type(value) in (list, tuple) else value
+
+        if "contacts" in parsed:
+            contacts = parsed.get("contacts")
+            if type(contacts) is list:
+                # handle IP-style contacts, which show up as a list
+                for contact in contacts:
+                    contact_type = contact.get("type")
+                    for key in (
+                        "name",
+                        "email",
+                        "org",
+                        "abuse_mailbos",
+                        "address",
+                        "street",
+                        "city",
+                        "state",
+                        "postal",
+                        "country",
+                        "phone",
+                        "fax",
+                    ):
+                        if key in contact:
+                            value = contact[key]
+                            flat["{0}_{1}".format(contact_type, key)] = " ".join(value) if type(value) in (list, tuple) else value
+
+            elif type(contacts) is dict:
+                for contact_type in ("registrant", "admin", "tech", "billing"):
+                    contact = contacts.get(contact_type, {})
+                    for key in ("name", "email", "org", "street", "city", "state", "postal", "country", "phone", "fax"):
+                        if key in contact:
+                            value = contact[key]
+                            flat["{0}_{1}".format(contact_type, key)] = " ".join(value) if type(value) in (list, tuple) else value
+
+        return flat
+
+
+class ParsedDomainRdap(Results):
+    """Returns the parsed domain rdap results in a format that can quickly be flattened"""
+
+    def flattened(self):
+        """Returns a flattened version of the parsed domain rdap data"""
+        parsed = self["parsed_domain_rdap"]
+        flat = OrderedDict()
+        for key in (
+            "domain",
+            "handle",
+            "domain_statuses",
+            "creation_date",
+            "last_changed_date",
+            "expiration_date",
+            "dnssec",
+            "nameservers",
+            "conformance",
+            "emails",
+            "email_domains",
+            "unclassified_emails",
+        ):
+            if key in parsed:
+                value = parsed[key]
+                flat[key] = " | ".join(value) if type(value) in (list, tuple) else value
+
+        registrar = parsed.get("registrar", {})
+        for registrar_key, registrar_value in registrar.items():
+            if registrar_key == "contacts":
+                for i, contact in enumerate(registrar_value, start=1):
+                    for contact_key, contact_value in contact.items():
+                        flat[f"registrar_contacts_{contact_key}"] = (
+                            " | ".join(contact_value) if type(contact_value) in (list, tuple) else contact_value
+                        )
+
+                continue
+            flat[f"registrar_{registrar_key}"] = registrar_value
+
+        contacts = parsed.get("contacts")
+        if contacts:
+            for i, contact in enumerate(contacts, start=1):
+                for contact_key, contact_value in contact.items():
+                    flat[f"contact_{contact_key}_{i}"] = " | ".join(contact_value) if type(contact_value) in (list, tuple) else contact_value
+
+        return flat

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: domaintools_api
-Version: 2.1.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.1.0 → domaintools_api-2.2.0}/domaintools_async/__init__.py

@@ -1,4 +1,5 @@
 """Adds async capabilities to the base product object"""
+
 import asyncio
 from httpx import AsyncClient
 
@@ -6,9 +7,14 @@ from domaintools.base_results import Results
 
 from domaintools.exceptions import ServiceUnavailableException, ServiceException
 
+
 class _AIter(object):
     """A wrapper to wrap an AsyncResults as an async iterable"""
-    __slots__ = ('results', 'iterator', )
+
+    __slots__ = (
+        "results",
+        "iterator",
+    )
 
     def __init__(self, results):
         self.results = results
@@ -35,11 +41,11 @@ class AsyncResults(Results):
         return self.__awaitable__().__await__()
 
     async def _make_async_request(self, session):
-        if self.product in ['iris-investigate', 'iris-enrich', 'iris-detect-escalate-domains']:
+        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)
             results = await 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)
             results = await session.patch(url=self.url, json=patch_data)
@@ -47,7 +53,7 @@ class AsyncResults(Results):
             results = await session.get(url=self.url, params=self.kwargs, **self.api.extra_request_params)
         if results:
             self.setStatus(results.status_code, results)
-            if self.kwargs.get('format', 'json') == 'json':
+            if self.kwargs.get("format", "json") == "json":
                 self._data = results.json()
             else:
                 self._data = results.text()
@@ -60,7 +66,7 @@ class AsyncResults(Results):
     async def __awaitable__(self):
         if self._data is None:
 
-            async with AsyncClient(verify=self.api.verify_ssl, proxies=self.api.proxy_url, timeout=None) as session:
+            async with AsyncClient(verify=self.api.verify_ssl, proxy=self.api.proxy_url, timeout=None) as session:
                 wait_time = self._wait_time()
                 if wait_time is None and self.api:
                     try:

{domaintools_api-2.1.0 → domaintools_api-2.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "domaintools_api"
 dependencies = ["httpx", "rich", "typer"]
-requires-python = ">= 3.6"
+requires-python = ">= 3.9"
 authors = [{ name = "DomainTools", email = "integrations@domaintools.com" }]
 description = "DomainTools Official Python API"
 readme = "README.md"
@@ -18,11 +18,6 @@ classifiers = [
     "Environment :: Console",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.6",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Topic :: Software Development :: Libraries",

{domaintools_api-2.1.0 → domaintools_api-2.2.0}/tests/test_api.py

@@ -153,6 +153,32 @@ def test_parsed_whois():
         assert isinstance(result.flattened(), dict)
 
 
+@vcr.use_cassette
+def test_parsed_domain_rdap():
+    api_call = api.parsed_domain_rdap("google.com")
+    with api_call as result:
+        for key in (
+            "handle",
+            "domain_statuses",
+            "creation_date",
+            "last_changed_date",
+            "expiration_date",
+            "nameservers",
+            "conformance",
+            "emails",
+            "email_domains",
+            "unclassified_emails",
+            "registrar",
+            "contacts",
+        ):
+            assert key in result.get("parsed_domain_rdap")
+
+        for key, value in result.items():
+            assert key
+
+        assert isinstance(result.flattened(), dict)
+
+
 @vcr.use_cassette
 def test_registrant_monitor():
     api_call = api.registrant_monitor("google")
@@ -385,7 +411,7 @@ def test_iris():
     with pytest.raises(ValueError):
         api.iris()
 
-    with api.iris(domain="google.com", https=False) as results:
+    with api.iris(domain="google.com") as results:
         assert results
         for result in results:
             assert "domain" in result
@@ -471,10 +497,10 @@ def test_iris_detect_watched_domains():
     detect_results = api.iris_detect_watched_domains(
         monitor_id="nAwmQg2pqg", sort=["risk_score"], order="desc"
     )
-    assert len(detect_results["watchlist_domains"]) == 0
+    assert len(detect_results["watchlist_domains"]) == 2
 
     detect_results = api.iris_detect_watched_domains(escalation_types="blocked")
-    assert detect_results["count"] == 0
+    assert detect_results["count"] == 1
 
 
 @vcr.use_cassette

{domaintools_api-2.1.0 → domaintools_api-2.2.0}/tests/test_cli.py

@@ -22,7 +22,7 @@ def test_valid_command():
     user = os.environ.get("TEST_USER", "test")
     key = os.environ.get("TEST_KEY", "key")
     result = runner.invoke(dt_cli, ["account_information", "--help"])
-    assert "Usage: main account_information" in result.stdout
+    assert "Provides a snapshot of your accounts current API usage." in result.stdout
 
 
 def test_invalid_command():

domaintools_api-2.1.0/VERSION

@@ -1 +0,0 @@
-2.1.0

domaintools_api-2.1.0/domaintools/results.py

@@ -1,81 +0,0 @@
-"""Defines the used Result object based on the current versions and/or features available to Python runtime
-
-Additionally, defines any custom result objects that may be used to enable more Pythonic interaction with endpoints.
-"""
-from itertools import chain
-
-try: # pragma: no cover
-    from collections import OrderedDict
-except ImportError: # pragma: no cover
-    from ordereddict import OrderedDict
-
-from itertools import zip_longest
-from domaintools_async import AsyncResults as Results
-
-class Reputation(Results):
-    """Returns the reputation results in a format that can quickly be converted into floats / ints"""
-
-    def __float__(self):
-        return float(self['risk_score'])
-
-    def __int__(self):
-        return int(self['risk_score'])
-
-
-class GroupedIterable(Results):
-    """Returns a results item in a format that allows for grouped iteration of mulpitle result lists"""
-
-    def _items(self):
-        if self._items_list is None:
-            self._items_list = chain(*[zip_longest([], value, fillvalue=key) for key, value in self.response().items()
-                                       if type(value) in (list, tuple)])
-
-        return self._items_list
-
-
-class ParsedWhois(Results):
-    """Returns the parsed whois results in a format that can quickly be flattened"""
-
-    def flattened(self):
-        """Returns a flattened version of the parsed whois data"""
-        parsed = self['parsed_whois']
-        flat = OrderedDict()
-        for key in ('domain', 'created_date', 'updated_date', 'expired_date', 'statuses', 'name_servers'):
-            if key in parsed:
-                value = parsed[key]
-                flat[key] = ' | '.join(value) if type(value) in (list, tuple) else value
-
-        registrar = parsed.get('registrar', {})
-        for key in ('name', 'abuse_contact_phone', 'abuse_contact_email', 'iana_id', 'url', 'whois_server'):
-            if key in registrar:
-                flat['registrar_{0}'.format(key)] = registrar[key]
-
-        if "networks" in parsed:
-            networks = parsed.get("networks")
-            for network in networks:
-                id = network.get("id")
-                for key in ('range', 'asn', 'org', 'parent', 'customer', 'country', 'phone', 'status', 'source', 'updated_date', 'created_date'):
-                    if key in network:
-                        value = network[key]
-                        flat['network_{0}'.format(id)] = ' '.join(value) if type(value) in (list, tuple) else value
-
-        if "contacts" in parsed:
-            contacts = parsed.get("contacts")
-            if type(contacts) is list:
-                # handle IP-style contacts, which show up as a list
-                for contact in contacts:
-                    contact_type = contact.get("type")
-                    for key in ('name', 'email', 'org', 'abuse_mailbos', 'address', 'street', 'city', 'state', 'postal', 'country', 'phone', 'fax'):
-                        if key in contact:
-                            value = contact[key]
-                            flat['{0}_{1}'.format(contact_type, key)] = ' '.join(value) if type(value) in (list, tuple) else value
-
-            elif type(contacts) is dict:
-                for contact_type in ('registrant', 'admin', 'tech', 'billing'):
-                    contact = contacts.get(contact_type, {})
-                    for key in ('name', 'email', 'org', 'street', 'city', 'state', 'postal', 'country', 'phone', 'fax'):
-                        if key in contact:
-                            value = contact[key]
-                            flat['{0}_{1}'.format(contact_type, key)] = ' '.join(value) if type(value) in (list, tuple) else value
-
-        return flat