a2ztools 1.0.0__tar.gz

a2ztools-1.0.0/.gitignore

@@ -0,0 +1,16 @@
+node_modules/
+bin/
+obj/
+*.nupkg
+*.snupkg
+__pycache__/
+*.egg-info/
+dist/
+.venv/
+.pytest_cache/
+vendor/
+composer.lock
+.phpunit.cache/
+*.zip
+.DS_Store
+.vs/

a2ztools-1.0.0/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 Reliable Software Technology (A2Z Tools)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The WordPress plugin in integrations/wordpress/ is licensed separately under
+GPL-2.0-or-later; see the header of that plugin.

a2ztools-1.0.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.5
+Name: a2ztools
+Version: 1.0.0
+Summary: Free API client for website checks: SSL certificate expiry, DNS, WHOIS (RDAP), SPF, DKIM, DMARC, security headers, robots.txt, llms.txt and more.
+Project-URL: Homepage, https://a2z.tools/developers
+Project-URL: Documentation, https://a2z.tools/developers
+Project-URL: Source, https://github.com/a2ztoolsdev-source/a2ztools
+Project-URL: Issues, https://github.com/a2ztoolsdev-source/a2ztools/issues
+Author-email: A2Z Tools <app@a2z.tools>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api-client,dkim,dmarc,dns,security-headers,seo,spf,ssl,website-monitoring,whois
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: Name Service (DNS)
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# a2ztools
+
+Free Python client for the [A2Z Tools public API](https://a2z.tools/developers). It covers 68 checks for SSL certificates, DNS, WHOIS (RDAP), SPF, DKIM, DMARC, security headers, robots.txt, llms.txt and site health. It uses only the standard library and needs Python 3.9+.
+
+```bash
+pip install a2ztools
+```
+
+```python
+from a2ztools import A2zClient, A2zApiError
+
+a2z = A2zClient("a2z_...")          # key optional
+cert = a2z.ssl.certificate("example.com")
+mx = a2z.dns.records("example.com", type="MX")
+
+try:
+    a2z.email.dmarc("example.com")
+except A2zApiError as e:
+    print(e.status, e.code, e.retry_after)
+
+print(a2z.last_rate_limit)
+```
+
+Without a key you get 10 calls a minute and 100 a day. A free key from <https://a2z.tools/developers> gives 60 a minute and 2,000 a day.
+
+MIT licensed.

a2ztools-1.0.0/README.md

@@ -0,0 +1,26 @@
+# a2ztools
+
+Free Python client for the [A2Z Tools public API](https://a2z.tools/developers). It covers 68 checks for SSL certificates, DNS, WHOIS (RDAP), SPF, DKIM, DMARC, security headers, robots.txt, llms.txt and site health. It uses only the standard library and needs Python 3.9+.
+
+```bash
+pip install a2ztools
+```
+
+```python
+from a2ztools import A2zClient, A2zApiError
+
+a2z = A2zClient("a2z_...")          # key optional
+cert = a2z.ssl.certificate("example.com")
+mx = a2z.dns.records("example.com", type="MX")
+
+try:
+    a2z.email.dmarc("example.com")
+except A2zApiError as e:
+    print(e.status, e.code, e.retry_after)
+
+print(a2z.last_rate_limit)
+```
+
+Without a key you get 10 calls a minute and 100 a day. A free key from <https://a2z.tools/developers> gives 60 a minute and 2,000 a day.
+
+MIT licensed.

a2ztools-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "a2ztools"
+dynamic = ["version"]
+description = "Free API client for website checks: SSL certificate expiry, DNS, WHOIS (RDAP), SPF, DKIM, DMARC, security headers, robots.txt, llms.txt and more."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "A2Z Tools", email = "app@a2z.tools" }]
+keywords = ["ssl", "dns", "whois", "dmarc", "spf", "dkim", "security-headers", "website-monitoring", "seo", "api-client"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Internet :: Name Service (DNS)",
+  "Topic :: Security",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://a2z.tools/developers"
+Documentation = "https://a2z.tools/developers"
+Source = "https://github.com/a2ztoolsdev-source/a2ztools"
+Issues = "https://github.com/a2ztoolsdev-source/a2ztools/issues"
+
+[tool.hatch.version]
+path = "src/a2ztools/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/a2ztools"]

a2ztools-1.0.0/src/a2ztools/__init__.py

@@ -0,0 +1,5 @@
+"""A2Z Tools public API client: https://a2z.tools/developers"""
+from ._version import __version__
+from .client import DEFAULT_BASE_URL, A2zApiError, A2zClient, RateLimit
+
+__all__ = ["A2zClient", "A2zApiError", "RateLimit", "DEFAULT_BASE_URL", "__version__"]

a2ztools-1.0.0/src/a2ztools/_endpoints.py

@@ -0,0 +1,325 @@
+# Generated by scripts/generate.mjs from openapi/openapi.json - do not edit.
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import A2zClient
+
+
+class SslGroup:
+    """SSL / TLS: Certificates, expiry, protocols, HSTS, OCSP and certificate transparency."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def certificate(self, host: str, port: Optional[int] = None) -> Dict[str, Any]:
+        """Certificate details and expiry. Connects to the host and returns the certificate chain, issuer, subject alternative names, validity dates and days until expiry. Results are cached for 1800 seconds. Try it in a browser: https://a2z.tools/ssl-certificate-checker"""
+        return self._client.call("ssl", "certificate", {"host": host, "port": port})
+
+    def protocols(self, host: str, port: Optional[int] = None) -> Dict[str, Any]:
+        """Supported TLS versions. Which TLS protocol versions the server accepts (TLS 1.0 to 1.3). Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "protocols", {"host": host, "port": port})
+
+    def https(self, domain: str) -> Dict[str, Any]:
+        """HTTPS availability. Whether the domain answers over HTTPS with a valid certificate. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "https", {"domain": domain})
+
+    def https_redirect(self, domain: str) -> Dict[str, Any]:
+        """HTTP to HTTPS redirect. Whether plain HTTP redirects to HTTPS, and how. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "https-redirect", {"domain": domain})
+
+    def hsts(self, domain: str) -> Dict[str, Any]:
+        """HSTS header. The Strict-Transport-Security header, parsed and checked. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "hsts", {"domain": domain})
+
+    def hsts_preload(self, domain: str) -> Dict[str, Any]:
+        """HSTS preload eligibility. Whether the domain meets the hstspreload.org requirements. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "hsts-preload", {"domain": domain})
+
+    def ocsp(self, url: str) -> Dict[str, Any]:
+        """OCSP status. Asks the certificate's OCSP responder whether it has been revoked. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "ocsp", {"url": url})
+
+    def crl(self, url: str) -> Dict[str, Any]:
+        """CRL revocation check. Checks the certificate against its CRL distribution point. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "crl", {"url": url})
+
+    def ciphers(self, url: str) -> Dict[str, Any]:
+        """Cipher suites. The cipher suites the server negotiates, graded. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "ciphers", {"url": url})
+
+    def certificate_transparency(self, url: str) -> Dict[str, Any]:
+        """Certificate transparency. Certificates logged for the domain in public CT logs. Results are cached for 1800 seconds."""
+        return self._client.call("ssl", "certificate-transparency", {"url": url})
+
+class DnsGroup:
+    """DNS: Records, propagation across public resolvers, reverse DNS and DNSSEC."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def records(self, domain: str, type: Optional[str] = None) -> Dict[str, Any]:
+        """DNS records. A, AAAA, CNAME, MX, NS, TXT, SOA, CAA and more. Omit type to get all common types. Results are cached for 300 seconds. Try it in a browser: https://a2z.tools/dns-lookup"""
+        return self._client.call("dns", "records", {"domain": domain, "type": type})
+
+    def propagation(self, domain: str, type: Optional[str] = None) -> Dict[str, Any]:
+        """DNS propagation. The answer from several public resolvers around the world, side by side. Counts as 2 calls. Results are cached for 300 seconds. Try it in a browser: https://a2z.tools/dns-propagation-checker"""
+        return self._client.call("dns", "propagation", {"domain": domain, "type": type})
+
+    def reverse(self, ip: str) -> Dict[str, Any]:
+        """Reverse DNS (PTR). The PTR name for an IP address. Results are cached for 300 seconds."""
+        return self._client.call("dns", "reverse", {"ip": ip})
+
+    def dnssec(self, domain: str) -> Dict[str, Any]:
+        """DNSSEC. Whether the zone is signed and the chain of trust validates. Results are cached for 300 seconds."""
+        return self._client.call("dns", "dnssec", {"domain": domain})
+
+class EmailGroup:
+    """Email authentication: SPF, DKIM, DMARC, BIMI, MTA-STS and TLS-RPT, separately or as one graded check."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def security(self, domain: str, dkim_selector: Optional[str] = None) -> Dict[str, Any]:
+        """Email security grade. SPF, DKIM, DMARC, BIMI, MTA-STS and TLS-RPT in one graded report. Results are cached for 900 seconds. Try it in a browser: https://a2z.tools/email-security-checker"""
+        return self._client.call("email", "security", {"domain": domain, "dkimSelector": dkim_selector})
+
+    def spf(self, domain: str) -> Dict[str, Any]:
+        """SPF record. The SPF record, parsed, with the DNS look-up count and problems. Results are cached for 900 seconds. Try it in a browser: https://a2z.tools/spf-checker"""
+        return self._client.call("email", "spf", {"domain": domain})
+
+    def dmarc(self, domain: str) -> Dict[str, Any]:
+        """DMARC record. The DMARC policy, parsed, with reporting addresses and problems. Results are cached for 900 seconds. Try it in a browser: https://a2z.tools/dmarc-checker"""
+        return self._client.call("email", "dmarc", {"domain": domain})
+
+    def dkim(self, domain: str, selector: str) -> Dict[str, Any]:
+        """DKIM record. The DKIM public key for a selector, parsed. Results are cached for 900 seconds. Try it in a browser: https://a2z.tools/dkim-checker"""
+        return self._client.call("email", "dkim", {"domain": domain, "selector": selector})
+
+    def bimi(self, domain: str, selector: Optional[str] = None) -> Dict[str, Any]:
+        """BIMI record. The BIMI record and logo location. Results are cached for 900 seconds."""
+        return self._client.call("email", "bimi", {"domain": domain, "selector": selector})
+
+    def mta_sts(self, domain: str) -> Dict[str, Any]:
+        """MTA-STS. The MTA-STS DNS record and policy file. Results are cached for 900 seconds."""
+        return self._client.call("email", "mta-sts", {"domain": domain})
+
+    def tls_rpt(self, domain: str) -> Dict[str, Any]:
+        """TLS-RPT. The SMTP TLS reporting record. Results are cached for 900 seconds."""
+        return self._client.call("email", "tls-rpt", {"domain": domain})
+
+class DomainGroup:
+    """Domain & IP: WHOIS over RDAP, IP and ASN information, reverse IP."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def whois(self, domain: str) -> Dict[str, Any]:
+        """WHOIS (RDAP). Registrar, registration and expiry dates, status and name servers, from RDAP. Results are cached for 3600 seconds. Try it in a browser: https://a2z.tools/whois-lookup"""
+        return self._client.call("domain", "whois", {"domain": domain})
+
+    def ip(self, ip: str) -> Dict[str, Any]:
+        """IP information. Network, owner and location information for an IP address. Results are cached for 3600 seconds."""
+        return self._client.call("domain", "ip", {"ip": ip})
+
+    def asn(self, asn: str) -> Dict[str, Any]:
+        """ASN information. The organisation and prefixes of an autonomous system. Results are cached for 3600 seconds."""
+        return self._client.call("domain", "asn", {"asn": asn})
+
+    def reverse_ip(self, ip: str) -> Dict[str, Any]:
+        """Reverse IP. Other host names seen on the same IP address. Results are cached for 3600 seconds."""
+        return self._client.call("domain", "reverse-ip", {"ip": ip})
+
+class HttpGroup:
+    """HTTP & headers: Status, redirects, response headers, security headers, CSP, CORS, cookies, caching and performance basics."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def headers(self, url: str) -> Dict[str, Any]:
+        """Response headers. The response headers of a URL. Results are cached for 300 seconds. Try it in a browser: https://a2z.tools/http-headers-checker"""
+        return self._client.call("http", "headers", {"url": url})
+
+    def status(self, url: str) -> Dict[str, Any]:
+        """HTTP status. The status code and response time of a URL. Results are cached for 300 seconds."""
+        return self._client.call("http", "status", {"url": url})
+
+    def redirects(self, url: str) -> Dict[str, Any]:
+        """Redirect chain. Every hop from the URL to its final destination. Results are cached for 300 seconds."""
+        return self._client.call("http", "redirects", {"url": url})
+
+    def security_headers(self, url: str) -> Dict[str, Any]:
+        """Security headers grade. HSTS, CSP, X-Frame-Options, X-Content-Type-Options, Referrer-Policy and Permissions-Policy, graded. Results are cached for 300 seconds. Try it in a browser: https://a2z.tools/security-headers-checker"""
+        return self._client.call("http", "security-headers", {"url": url})
+
+    def csp(self, url: str) -> Dict[str, Any]:
+        """Content-Security-Policy. The CSP header parsed directive by directive, with weaknesses. Results are cached for 300 seconds."""
+        return self._client.call("http", "csp", {"url": url})
+
+    def cors(self, url: str) -> Dict[str, Any]:
+        """CORS configuration. The CORS headers a URL sends, with risky combinations flagged. Results are cached for 300 seconds."""
+        return self._client.call("http", "cors", {"url": url})
+
+    def cookies(self, url: str) -> Dict[str, Any]:
+        """Cookies. Cookies set by the URL and their Secure, HttpOnly and SameSite flags. Results are cached for 300 seconds."""
+        return self._client.call("http", "cookies", {"url": url})
+
+    def methods(self, url: str) -> Dict[str, Any]:
+        """Allowed HTTP methods. Which HTTP methods the server accepts. Results are cached for 300 seconds."""
+        return self._client.call("http", "methods", {"url": url})
+
+    def server_banner(self, url: str) -> Dict[str, Any]:
+        """Server banner. Server software and version disclosed in headers. Results are cached for 300 seconds."""
+        return self._client.call("http", "server-banner", {"url": url})
+
+    def framing(self, url: str) -> Dict[str, Any]:
+        """Clickjacking protection. Whether the page can be framed by other sites. Results are cached for 300 seconds."""
+        return self._client.call("http", "framing", {"url": url})
+
+    def cross_origin(self, url: str) -> Dict[str, Any]:
+        """Cross-origin headers. COOP, COEP and CORP headers. Results are cached for 300 seconds."""
+        return self._client.call("http", "cross-origin", {"url": url})
+
+    def cross_origin_isolation(self, url: str) -> Dict[str, Any]:
+        """Cross-origin isolation. Whether the page is cross-origin isolated. Results are cached for 300 seconds."""
+        return self._client.call("http", "cross-origin-isolation", {"url": url})
+
+    def permissions_policy(self, url: str) -> Dict[str, Any]:
+        """Permissions-Policy. The Permissions-Policy header, parsed. Results are cached for 300 seconds."""
+        return self._client.call("http", "permissions-policy", {"url": url})
+
+    def referrer_policy(self, url: str) -> Dict[str, Any]:
+        """Referrer-Policy. The Referrer-Policy in effect. Results are cached for 300 seconds."""
+        return self._client.call("http", "referrer-policy", {"url": url})
+
+    def compression(self, url: str) -> Dict[str, Any]:
+        """Compression. Whether gzip, Brotli or zstd is served. Results are cached for 300 seconds."""
+        return self._client.call("http", "compression", {"url": url})
+
+    def cache_control(self, url: str) -> Dict[str, Any]:
+        """Caching headers. Cache-Control, ETag, Last-Modified and Expires, explained. Results are cached for 300 seconds."""
+        return self._client.call("http", "cache-control", {"url": url})
+
+    def protocol(self, url: str) -> Dict[str, Any]:
+        """HTTP version. HTTP/1.1, HTTP/2 or HTTP/3 support. Results are cached for 300 seconds."""
+        return self._client.call("http", "protocol", {"url": url})
+
+    def ttfb(self, url: str) -> Dict[str, Any]:
+        """Time to first byte. DNS, connect, TLS and first-byte timings from our server. Results are cached for 60 seconds."""
+        return self._client.call("http", "ttfb", {"url": url})
+
+    def cdn(self, domain: str) -> Dict[str, Any]:
+        """CDN detection. Which CDN serves the domain, if any. Results are cached for 300 seconds."""
+        return self._client.call("http", "cdn", {"domain": domain})
+
+    def static_assets(self, url: str) -> Dict[str, Any]:
+        """Static asset audit. Size, caching and compression of the page's scripts, styles and images. Results are cached for 300 seconds."""
+        return self._client.call("http", "static-assets", {"url": url})
+
+class SeoGroup:
+    """SEO & crawlers: Open Graph, canonical, hreflang, structured data, robots.txt, sitemaps, llms.txt, AI crawler access and ads.txt."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def open_graph(self, url: str) -> Dict[str, Any]:
+        """Open Graph & Twitter cards. og: and twitter: tags, with missing or broken values flagged. Results are cached for 600 seconds."""
+        return self._client.call("seo", "open-graph", {"url": url})
+
+    def canonical(self, url: str) -> Dict[str, Any]:
+        """Canonical URL. The canonical link and whether it agrees with the URL. Results are cached for 600 seconds."""
+        return self._client.call("seo", "canonical", {"url": url})
+
+    def hreflang(self, url: str) -> Dict[str, Any]:
+        """hreflang. hreflang alternates and reciprocal-link problems. Results are cached for 600 seconds."""
+        return self._client.call("seo", "hreflang", {"url": url})
+
+    def schema(self, url: str) -> Dict[str, Any]:
+        """Structured data. JSON-LD, Microdata and RDFa found on the page, validated. Results are cached for 600 seconds."""
+        return self._client.call("seo", "schema", {"url": url})
+
+    def mixed_content(self, url: str) -> Dict[str, Any]:
+        """Mixed content. HTTP resources loaded by an HTTPS page. Results are cached for 600 seconds."""
+        return self._client.call("seo", "mixed-content", {"url": url})
+
+    def technology(self, url: str) -> Dict[str, Any]:
+        """Technology detection. CMS, frameworks, analytics and hosting the page uses. Results are cached for 600 seconds."""
+        return self._client.call("seo", "technology", {"url": url})
+
+    def robots_txt(self, domain: str) -> Dict[str, Any]:
+        """robots.txt. The robots.txt file, parsed by user agent. Results are cached for 600 seconds. Try it in a browser: https://a2z.tools/robots-txt-checker"""
+        return self._client.call("seo", "robots-txt", {"domain": domain})
+
+    def sitemap(self, url: str) -> Dict[str, Any]:
+        """XML sitemap. Fetches and validates an XML sitemap or sitemap index. Results are cached for 600 seconds."""
+        return self._client.call("seo", "sitemap", {"url": url})
+
+    def llms_txt(self, domain: str) -> Dict[str, Any]:
+        """llms.txt. Whether the site publishes /llms.txt, and whether it is well formed. Results are cached for 600 seconds. Try it in a browser: https://a2z.tools/llms-txt-checker"""
+        return self._client.call("seo", "llms-txt", {"domain": domain})
+
+    def ai_crawlers(self, domain: str) -> Dict[str, Any]:
+        """AI crawler access. Which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended and others) robots.txt allows. Results are cached for 600 seconds. Try it in a browser: https://a2z.tools/ai-crawler-access-checker"""
+        return self._client.call("seo", "ai-crawlers", {"domain": domain})
+
+    def ads_txt(self, domain: str) -> Dict[str, Any]:
+        """ads.txt. The ads.txt file, parsed and validated. Results are cached for 600 seconds. Try it in a browser: https://a2z.tools/ads-txt-checker"""
+        return self._client.call("seo", "ads-txt", {"domain": domain})
+
+    def app_ads_txt(self, domain: str) -> Dict[str, Any]:
+        """app-ads.txt. The app-ads.txt file, parsed and validated. Results are cached for 600 seconds."""
+        return self._client.call("seo", "app-ads-txt", {"domain": domain})
+
+class SiteGroup:
+    """Site health: One-call health summaries, PWA manifest, favicon, security.txt and front-end dependency checks."""
+
+    def __init__(self, client: "A2zClient") -> None:
+        self._client = client
+
+    def health(self, domain: str) -> Dict[str, Any]:
+        """Website health summary. DNS, HTTPS, certificate expiry, security headers and email authentication in one call. Counts as 3 calls. Counts as 3 calls. Results are cached for 900 seconds. Try it in a browser: https://a2z.tools/website-health-checker"""
+        return self._client.call("site", "health", {"domain": domain})
+
+    def audit(self, domain: str) -> Dict[str, Any]:
+        """Website security audit. The full security audit behind the A2Z website audit tool. Counts as 5 calls. Counts as 5 calls. Results are cached for 900 seconds."""
+        return self._client.call("site", "audit", {"domain": domain})
+
+    def security_txt(self, domain: str) -> Dict[str, Any]:
+        """security.txt. The /.well-known/security.txt file, parsed and validated. Results are cached for 900 seconds."""
+        return self._client.call("site", "security-txt", {"domain": domain})
+
+    def manifest(self, url: str) -> Dict[str, Any]:
+        """Web app manifest. The PWA manifest, validated for installability. Results are cached for 900 seconds."""
+        return self._client.call("site", "manifest", {"url": url})
+
+    def service_worker(self, url: str) -> Dict[str, Any]:
+        """Service worker. Whether the page registers a service worker. Results are cached for 900 seconds."""
+        return self._client.call("site", "service-worker", {"url": url})
+
+    def favicon(self, url: str) -> Dict[str, Any]:
+        """Favicons. Every favicon and touch icon the page declares, with sizes. Results are cached for 900 seconds."""
+        return self._client.call("site", "favicon", {"url": url})
+
+    def third_party_scripts(self, url: str) -> Dict[str, Any]:
+        """Third-party scripts. Scripts loaded from other domains, grouped by owner. Results are cached for 900 seconds."""
+        return self._client.call("site", "third-party-scripts", {"url": url})
+
+    def external_resources(self, url: str) -> Dict[str, Any]:
+        """External resources. Every external resource the page loads. Results are cached for 900 seconds."""
+        return self._client.call("site", "external-resources", {"url": url})
+
+    def source_maps(self, url: str) -> Dict[str, Any]:
+        """Exposed source maps. Publicly reachable JavaScript source maps. Results are cached for 900 seconds."""
+        return self._client.call("site", "source-maps", {"url": url})
+
+    def dependencies(self, url: str) -> Dict[str, Any]:
+        """Front-end dependencies. JavaScript libraries and versions detected on the page. Results are cached for 900 seconds."""
+        return self._client.call("site", "dependencies", {"url": url})
+
+    def vulnerable_libraries(self, url: str) -> Dict[str, Any]:
+        """Vulnerable libraries. Detected libraries with known vulnerabilities. Results are cached for 900 seconds."""
+        return self._client.call("site", "vulnerable-libraries", {"url": url})
+
+
+GROUPS = {"ssl": SslGroup, "dns": DnsGroup, "email": EmailGroup, "domain": DomainGroup, "http": HttpGroup, "seo": SeoGroup, "site": SiteGroup}

a2ztools-1.0.0/src/a2ztools/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

a2ztools-1.0.0/src/a2ztools/client.py

@@ -0,0 +1,118 @@
+"""Client for the A2Z Tools public API (https://a2z.tools/developers). Standard library only."""
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, Mapping, Optional
+
+from . import _endpoints
+from ._version import __version__
+
+DEFAULT_BASE_URL = "https://a2z.tools/public-api/v1"
+
+
+class A2zApiError(Exception):
+    """An error answer from the API (4xx/5xx), or a request that never got one."""
+
+    def __init__(self, message: str, status: int = 0, code: Optional[str] = None,
+                 retry_after: Optional[int] = None, body: Any = None) -> None:
+        super().__init__(message)
+        #: HTTP status, or 0 when there was no answer.
+        self.status = status
+        #: missing_parameter, invalid_key, key_suspended, key_revoked, key_required,
+        #: rate_limited, daily_quota, target_rate_limited, api_disabled, network_error
+        self.code = code
+        #: Seconds to wait before retrying (429 / 503).
+        self.retry_after = retry_after
+        self.body = body
+
+
+@dataclass
+class RateLimit:
+    limit: int
+    remaining: Optional[int]
+    #: Next reset (00:00 UTC).
+    reset: Optional[datetime]
+    #: True when the answer came from the API's cache.
+    cached: bool
+
+
+def _int(value: Optional[str]) -> Optional[int]:
+    try:
+        return int(value) if value not in (None, "") else None
+    except ValueError:
+        return None
+
+
+class A2zClient:
+    """Free website, DNS, SSL, email-authentication and SEO checks.
+
+    >>> client = A2zClient(api_key="a2z_...")      # the key is optional
+    >>> client.ssl.certificate(host="example.com")["result"]["daysRemaining"]
+
+    Each check returns the decoded JSON answer. ``ok`` is False when the check ran but
+    found a problem (for example no record); API errors raise :class:`A2zApiError`.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, *, site: Optional[str] = None,
+                 base_url: str = DEFAULT_BASE_URL, timeout: float = 30.0, opener: Any = None) -> None:
+        self._api_key = api_key
+        self._site_host = site
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._opener = opener or urllib.request.build_opener()
+        #: Limits from the most recent response.
+        self.last_rate_limit: Optional[RateLimit] = None
+        for name, cls in _endpoints.GROUPS.items():
+            setattr(self, name, cls(self))
+
+    def call(self, group: str, name: str, params: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]:
+        """Calls any endpoint by group and name, e.g. ``call("ssl", "certificate", {"host": "example.com"})``."""
+        query = {k: str(v) for k, v in (params or {}).items() if v is not None and v != ""}
+        url = f"{self._base_url}/{group}/{name}"
+        if query:
+            url += "?" + urllib.parse.urlencode(query)
+
+        headers = {"Accept": "application/json", "User-Agent": f"a2ztools-python/{__version__}"}
+        if self._api_key:
+            headers["X-API-Key"] = self._api_key
+        if self._site_host:
+            headers["X-A2Z-Site"] = self._site_host
+
+        request = urllib.request.Request(url, headers=headers, method="GET")
+        try:
+            response = self._opener.open(request, timeout=self._timeout)
+            status, resp_headers, raw = response.status, response.headers, response.read()
+        except urllib.error.HTTPError as err:
+            status, resp_headers, raw = err.code, err.headers, err.read()
+        except (urllib.error.URLError, OSError) as err:
+            raise A2zApiError(f"Request to {group}/{name} failed: {err}", 0, "network_error") from err
+
+        self.last_rate_limit = self._rate_limit(resp_headers) or self.last_rate_limit
+        try:
+            body = json.loads(raw.decode("utf-8")) if raw else None
+        except ValueError:
+            body = None
+
+        if status >= 400:
+            message = body.get("error") if isinstance(body, dict) else None
+            code = body.get("code") if isinstance(body, dict) else None
+            raise A2zApiError(message or f"HTTP {status}", status, code, _int(resp_headers.get("Retry-After")), body)
+        return body
+
+    @staticmethod
+    def _rate_limit(headers: Any) -> Optional[RateLimit]:
+        limit = _int(headers.get("X-RateLimit-Limit"))
+        if limit is None:
+            return None
+        reset = _int(headers.get("X-RateLimit-Reset"))
+        return RateLimit(
+            limit=limit,
+            remaining=_int(headers.get("X-RateLimit-Remaining")),
+            reset=datetime.fromtimestamp(reset, tz=timezone.utc) if reset is not None else None,
+            cached=headers.get("X-A2Z-Cache") == "HIT",
+        )

a2ztools-1.0.0/tests/test_client.py

@@ -0,0 +1,100 @@
+import io
+import json
+import urllib.error
+from email.message import Message
+
+import pytest
+
+from a2ztools import A2zApiError, A2zClient
+
+
+class FakeResponse:
+    def __init__(self, status, body, headers):
+        self.status = status
+        self.headers = headers
+        self._body = body
+
+    def read(self):
+        return self._body
+
+
+def make_headers(values):
+    m = Message()
+    for k, v in values.items():
+        m[k] = v
+    return m
+
+
+class FakeOpener:
+    def __init__(self, status=200, body=None, headers=None):
+        self.status = status
+        self.body = json.dumps(body if body is not None else {"ok": True}).encode()
+        self.headers = make_headers(headers or {})
+        self.requests = []
+
+    def open(self, request, timeout=None):
+        self.requests.append(request)
+        if self.status >= 400:
+            raise urllib.error.HTTPError(request.full_url, self.status, "error", self.headers, io.BytesIO(self.body))
+        return FakeResponse(self.status, self.body, self.headers)
+
+
+def test_every_group_is_attached():
+    c = A2zClient(opener=FakeOpener())
+    for group in ("ssl", "dns", "email", "domain", "http", "seo", "site"):
+        assert hasattr(c, group)
+    assert callable(c.site.health)
+    assert callable(c.email.security)
+
+
+def test_url_headers_and_rate_limit():
+    o = FakeOpener(body={"ok": True, "domain": "example.com"}, headers={
+        "X-RateLimit-Limit": "2000", "X-RateLimit-Remaining": "1999",
+        "X-RateLimit-Reset": "1793232000", "X-A2Z-Cache": "HIT"})
+    c = A2zClient("a2z_test", site="shop.example", opener=o)
+    r = c.dns.records("example.com", type="MX")
+    assert r["domain"] == "example.com"
+    req = o.requests[0]
+    assert req.full_url == "https://a2z.tools/public-api/v1/dns/records?domain=example.com&type=MX"
+    assert req.get_header("X-api-key") == "a2z_test"
+    assert req.get_header("X-a2z-site") == "shop.example"
+    assert c.last_rate_limit.limit == 2000
+    assert c.last_rate_limit.remaining == 1999
+    assert c.last_rate_limit.cached is True
+    assert c.last_rate_limit.reset.isoformat() == "2026-10-29T00:00:00+00:00"
+
+
+def test_optional_parameters_are_left_out_and_snake_case_maps_back():
+    o = FakeOpener()
+    c = A2zClient(opener=o, base_url="http://localhost:1/public-api/v1/")
+    c.ssl.certificate("a2z.tools")
+    c.email.security("google.com", dkim_selector="google")
+    assert o.requests[0].full_url == "http://localhost:1/public-api/v1/ssl/certificate?host=a2z.tools"
+    assert o.requests[1].full_url.endswith("/email/security?domain=google.com&dkimSelector=google")
+
+
+def test_errors_raise_with_code_and_retry_after():
+    o = FakeOpener(status=429, body={"ok": False, "code": "rate_limited", "error": "Too many requests"}, headers={"Retry-After": "17"})
+    c = A2zClient(opener=o)
+    with pytest.raises(A2zApiError) as e:
+        c.seo.llms_txt("x.com")
+    assert e.value.status == 429
+    assert e.value.code == "rate_limited"
+    assert e.value.retry_after == 17
+    assert str(e.value) == "Too many requests"
+
+
+def test_a_check_that_found_nothing_is_not_an_error():
+    c = A2zClient(opener=FakeOpener(body={"ok": False, "error": "Not found (HTTP 404)"}))
+    assert c.seo.llms_txt("example.com")["ok"] is False
+
+
+def test_network_errors():
+    class Broken:
+        def open(self, request, timeout=None):
+            raise urllib.error.URLError("no route")
+
+    with pytest.raises(A2zApiError) as e:
+        A2zClient(opener=Broken()).http.status("https://x.com")
+    assert e.value.code == "network_error"
+    assert e.value.status == 0