aitoolsblocklist 1.0.0__tar.gz

aitoolsblocklist-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alpha Quantum
+
+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.

aitoolsblocklist-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

aitoolsblocklist-1.0.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.1
+Name: aitoolsblocklist
+Version: 1.0.0
+Summary: Python client for the AI Tools Blocklist API — classified AI-tool domains for web filtering, DNS security, and DLP.
+Home-page: https://www.aitoolsblocklist.com
+Author: Alpha Quantum
+Author-email: info@alpha-quantum.com
+License: MIT
+Project-URL: Homepage, https://www.aitoolsblocklist.com
+Project-URL: API Documentation, https://www.aitoolsblocklist.com/ai-blocklist-api.php
+Project-URL: Source, https://www.aitoolsblocklist.com
+Description: # aitoolsblocklist
+        
+        A lightweight, production-ready Python client for the [AI Tools Blocklist API](https://www.aitoolsblocklist.com) — a daily-refreshed database of classified AI-tool domains built for web filtering, DNS security, data-loss prevention, and acceptable-use enforcement. The package wraps the REST API in a small, typed, dependency-light interface so security engineers, network administrators, and compliance teams can look up, filter, and synchronize AI-tool domain intelligence directly from Python.
+        
+        The underlying dataset is a specialized extraction from a 102-million-domain enterprise web filtering infrastructure. It contains tens of thousands of AI-tool domains — chatbots, code assistants, image and video generators, voice-cloning services, autonomous agents, AI companions, and more — each classified into functional categories and subcategories rather than a single flat "AI" label. That granularity is what makes per-category policy possible: permit an approved AI tutor while blocking a deepfake generator, or allow a coding assistant while flagging an unvetted document-processing service.
+        
+        ---
+        
+        ## Installation
+        
+        ```bash
+        pip install aitoolsblocklist
+        ```
+        
+        The only runtime dependency is [`requests`](https://requests.readthedocs.io/). Python 3.7 and newer are supported.
+        
+        ## Quick start
+        
+        ```python
+        from aitoolsblocklist import AIToolsBlocklistClient
+        
+        client = AIToolsBlocklistClient("atb_your_api_key_here")
+        
+        # Single lookup — is this domain an AI tool, and what kind?
+        result = client.lookup("claude.ai")
+        print(result["in_blocklist"])        # True
+        print(result["primary_category"])    # "Text & Language"
+        print(result["subcategory"])         # "General assistants & chatbots"
+        print(result["risk_tier"])           # "high"
+        
+        # A convenience boolean for policy gates
+        if client.is_blocked("midjourney.com"):
+            enforce_block_policy("midjourney.com")
+        ```
+        
+        An API key is required and is available from the account dashboard after subscribing to any paid plan. Keys use the `atb_` prefix for easy identification in logs, and are passed automatically as a Bearer token on every request.
+        
+        ## Technical overview
+        
+        ### Authentication and configuration
+        
+        The client sends your key in the `Authorization: Bearer` header, requests gzip-compressed responses, and sets a descriptive `User-Agent`. Construction takes a handful of options:
+        
+        ```python
+        client = AIToolsBlocklistClient(
+            api_key="atb_your_api_key_here",
+            base_url="https://api.aitoolsblocklist.com/v1",  # override for testing
+            timeout=30,        # per-request timeout, seconds
+            max_retries=3,     # automatic backoff on 429 and 5xx
+        )
+        ```
+        
+        Transient failures — HTTP 429 rate limits and 5xx server errors — are retried automatically with exponential backoff, honoring the `Retry-After` header when present. Authentication problems raise immediately, because retrying a revoked key is pointless.
+        
+        ### Endpoints and methods
+        
+        Each REST endpoint maps to a single method:
+        
+        | Method | Endpoint | Purpose |
+        | --- | --- | --- |
+        | `lookup(domain)` | `GET /v1/lookup/{domain}` | Classify one domain |
+        | `is_blocked(domain)` | — | Convenience boolean wrapper |
+        | `bulk_lookup(domains)` | `POST /v1/bulk-lookup` | Classify up to 1,000 domains |
+        | `bulk_lookup_all(domains)` | — | Auto-chunks any number of domains |
+        | `domains(**filters)` | `GET /v1/domains` | One filtered, paginated page |
+        | `iter_domains(**filters)` | — | Iterate the entire filtered list |
+        | `delta(since)` | `GET /v1/delta` | Changes since a timestamp |
+        | `taxonomy()` | `GET /v1/taxonomy` | Category tree with IDs |
+        | `stats()` | `GET /v1/stats` | Database statistics |
+        
+        ### Single and bulk lookups
+        
+        Pass a bare domain — `claude.ai`, not `https://claude.ai/chat`. Subdomains resolve to their registrable domain, so `chat.openai.com` returns the classification for `openai.com`. Both found and not-found responses are HTTP 200; your integration checks one unambiguous `in_blocklist` boolean instead of distinguishing "not found" from "bad request."
+        
+        ```python
+        report = client.bulk_lookup(["openai.com", "github.com", "notion.so"])
+        for row in report["results"]:
+            print(row["domain"], row["in_blocklist"], row.get("primary_category"))
+        
+        # For arbitrarily large inputs, chunking is handled for you:
+        everything = client.bulk_lookup_all(my_10000_domains)
+        ```
+        
+        ### Loading and synchronizing the full list
+        
+        For a local cache, DNS sinkhole, or firewall External Dynamic List, stream the full classified list. `iter_domains()` walks cursor-based pagination transparently:
+        
+        ```python
+        with open("ai_blocklist.txt", "w") as fh:
+            for record in client.iter_domains(status="active", min_confidence=0.9):
+                fh.write(record["domain"] + "\n")
+        ```
+        
+        Then keep it current with a daily delta sync instead of re-downloading everything:
+        
+        ```python
+        changes = client.delta(since="2026-07-01T00:00:00Z")
+        for added in changes["added"]:
+            local_set.add(added["domain"])
+        for removed in changes["removed"]:
+            local_set.discard(removed["domain"])
+        ```
+        
+        This "full load once, delta forever" pattern lets a modest request quota back millions of local lookups, because the actual matching happens in your own Redis, SQLite, or flat file.
+        
+        ### Error handling
+        
+        The client raises a small, specific exception hierarchy so callers can react precisely:
+        
+        ```python
+        from aitoolsblocklist import (
+            AIToolsBlocklistError, AuthenticationError,
+            RateLimitError, NotFoundError,
+        )
+        
+        try:
+            result = client.lookup("example.com")
+        except AuthenticationError:
+            ...   # 401/403 — rotate or renew the key
+        except RateLimitError:
+            ...   # 429 after retries — back off or upgrade the plan
+        except AIToolsBlocklistError:
+            ...   # any other API or network failure
+        ```
+        
+        The client is also a context manager, so the underlying HTTP session is cleaned up automatically:
+        
+        ```python
+        with AIToolsBlocklistClient("atb_your_api_key_here") as client:
+            print(client.stats())
+        ```
+        
+        ---
+        
+        ## Why domain-level AI classification is needed
+        
+        The technical interface above solves a problem that has become urgent for nearly every organization that runs a network: **you can no longer see, let alone govern, where your data goes when employees and students use AI tools.**
+        
+        Two years ago, "AI at work" meant a handful of well-known services. Today, thousands of AI products launch every month, each with its own domain, and each capable of receiving text, code, images, or documents that a user pastes in. A blanket firewall rule cannot keep up, and a hand-maintained list of the famous fifty tools is stale within a week. The result is *shadow AI*: unsanctioned tools processing sensitive information with no oversight. Surveys of enterprise security leaders consistently rank data exposure through generative AI among their fastest-growing risks, and the guidance emerging from public research institutions reflects the same concern.
+        
+        ### The data-governance problem
+        
+        When an employee pastes a customer contract into an unfamiliar AI summarizer, or a developer sends proprietary source code to an online "explain this function" tool, that data leaves the organization's control. It may be logged, used for model training, or retained indefinitely. This is not a hypothetical: the U.S. National Institute of Standards and Technology's [AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework) explicitly identifies data confidentiality and third-party dependency as core risks to be mapped and managed, and encourages organizations to maintain an inventory of the AI systems their people actually use. You cannot inventory what you cannot see, and you cannot see AI-tool usage at the network layer without knowing which of the millions of domains crossing your egress are AI tools in the first place.
+        
+        Foundational work on the risks of large-scale models — for example, research hosted on [arXiv](https://arxiv.org/) from academic and industry labs — has documented how readily these systems memorize and can surface training data, which is precisely why unsanctioned data submission matters. Domain-level classification is the practical control point: it turns an unbounded, ever-changing population of AI services into a queryable list your existing security stack can act on.
+        
+        ### Education and duty of care
+        
+        Schools face a sharper version of the same problem, layered on top of legal obligations. In the United States, districts that receive certain federal funding must operate a technology protection measure under the Children's Internet Protection Act — the [Federal Communications Commission's CIPA guidance](https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act) sets out the requirement. AI chatbots, essay generators, and deepfake tools complicate that duty enormously: a district may want to *permit* an approved AI tutor that supports learning while *blocking* an essay-writing service that undermines academic integrity, or a companion-chat app inappropriate for minors. A single "AI" category cannot express that policy; per-subcategory classification can.
+        
+        Academic-integrity offices are grappling with the same distinction. University teaching-and-learning centers — such as the guidance published by [Stanford University](https://www.stanford.edu/) and other institutions on generative AI in coursework — increasingly frame the question not as "AI or no AI" but as "which uses of which tools are appropriate for which assignments." Enforcing a nuanced policy at the network level requires data that is equally nuanced.
+        
+        ### Why a purpose-built, refreshed feed
+        
+        General web-categorization databases were not designed for this. They answer "is this a shopping site, a news site, a social network?" — not "is this an AI code assistant, an AI voice cloner, or an AI research agent?" The pace is also different: general categories are stable for years, whereas AI tools appear and disappear weekly. The dataset behind this client is rebuilt daily precisely so that new tools are caught close to launch rather than months later, and it is organized around the functional distinctions that policy actually turns on.
+        
+        The public-interest research community has long argued that transparency and classification are prerequisites for governing new technologies. Digital-rights organizations such as the [Electronic Frontier Foundation](https://www.eff.org/) emphasize that filtering and monitoring must be precise and accountable rather than blunt — and precision is exactly what per-category domain intelligence enables. A well-classified feed lets an administrator write a rule that blocks a genuine risk category without collaterally breaking legitimate, sanctioned tools, which is the difference between a policy people follow and one they route around.
+        
+        ### Where this package fits
+        
+        This library is the thin, reliable bridge between that intelligence and your own systems. Drop `lookup()` into a proxy plugin or SOAR playbook for real-time decisions; use `iter_domains()` to seed a DNS sinkhole or firewall EDL; run `delta()` on a nightly cron to stay current. Because the heavy matching runs locally against data you have already synced, the approach scales from a single script to millions of lookups a day without hammering the API.
+        
+        If AI-tool visibility and control are on your roadmap — for security, for compliance, or for duty of care — the [AI Tools Blocklist](https://www.aitoolsblocklist.com) provides the data, and this package provides the Python integration.
+        
+        ---
+        
+        ## Links
+        
+        - Product and API documentation: [https://www.aitoolsblocklist.com](https://www.aitoolsblocklist.com)
+        - NIST AI Risk Management Framework: [https://www.nist.gov/itl/ai-risk-management-framework](https://www.nist.gov/itl/ai-risk-management-framework)
+        - FCC — Children's Internet Protection Act: [https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act](https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act)
+        - arXiv (open-access research): [https://arxiv.org/](https://arxiv.org/)
+        
+        ## License
+        
+        MIT
+        
+Keywords: ai tools blocklist,web filtering,dns filtering,content filtering,ai domain classification,shadow ai,data loss prevention,dlp,cipa,acceptable use policy,ai governance,domain categorization
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Networking :: Firewalls
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown

aitoolsblocklist-1.0.0/README.md

@@ -0,0 +1,176 @@
+# aitoolsblocklist
+
+A lightweight, production-ready Python client for the [AI Tools Blocklist API](https://www.aitoolsblocklist.com) — a daily-refreshed database of classified AI-tool domains built for web filtering, DNS security, data-loss prevention, and acceptable-use enforcement. The package wraps the REST API in a small, typed, dependency-light interface so security engineers, network administrators, and compliance teams can look up, filter, and synchronize AI-tool domain intelligence directly from Python.
+
+The underlying dataset is a specialized extraction from a 102-million-domain enterprise web filtering infrastructure. It contains tens of thousands of AI-tool domains — chatbots, code assistants, image and video generators, voice-cloning services, autonomous agents, AI companions, and more — each classified into functional categories and subcategories rather than a single flat "AI" label. That granularity is what makes per-category policy possible: permit an approved AI tutor while blocking a deepfake generator, or allow a coding assistant while flagging an unvetted document-processing service.
+
+---
+
+## Installation
+
+```bash
+pip install aitoolsblocklist
+```
+
+The only runtime dependency is [`requests`](https://requests.readthedocs.io/). Python 3.7 and newer are supported.
+
+## Quick start
+
+```python
+from aitoolsblocklist import AIToolsBlocklistClient
+
+client = AIToolsBlocklistClient("atb_your_api_key_here")
+
+# Single lookup — is this domain an AI tool, and what kind?
+result = client.lookup("claude.ai")
+print(result["in_blocklist"])        # True
+print(result["primary_category"])    # "Text & Language"
+print(result["subcategory"])         # "General assistants & chatbots"
+print(result["risk_tier"])           # "high"
+
+# A convenience boolean for policy gates
+if client.is_blocked("midjourney.com"):
+    enforce_block_policy("midjourney.com")
+```
+
+An API key is required and is available from the account dashboard after subscribing to any paid plan. Keys use the `atb_` prefix for easy identification in logs, and are passed automatically as a Bearer token on every request.
+
+## Technical overview
+
+### Authentication and configuration
+
+The client sends your key in the `Authorization: Bearer` header, requests gzip-compressed responses, and sets a descriptive `User-Agent`. Construction takes a handful of options:
+
+```python
+client = AIToolsBlocklistClient(
+    api_key="atb_your_api_key_here",
+    base_url="https://api.aitoolsblocklist.com/v1",  # override for testing
+    timeout=30,        # per-request timeout, seconds
+    max_retries=3,     # automatic backoff on 429 and 5xx
+)
+```
+
+Transient failures — HTTP 429 rate limits and 5xx server errors — are retried automatically with exponential backoff, honoring the `Retry-After` header when present. Authentication problems raise immediately, because retrying a revoked key is pointless.
+
+### Endpoints and methods
+
+Each REST endpoint maps to a single method:
+
+| Method | Endpoint | Purpose |
+| --- | --- | --- |
+| `lookup(domain)` | `GET /v1/lookup/{domain}` | Classify one domain |
+| `is_blocked(domain)` | — | Convenience boolean wrapper |
+| `bulk_lookup(domains)` | `POST /v1/bulk-lookup` | Classify up to 1,000 domains |
+| `bulk_lookup_all(domains)` | — | Auto-chunks any number of domains |
+| `domains(**filters)` | `GET /v1/domains` | One filtered, paginated page |
+| `iter_domains(**filters)` | — | Iterate the entire filtered list |
+| `delta(since)` | `GET /v1/delta` | Changes since a timestamp |
+| `taxonomy()` | `GET /v1/taxonomy` | Category tree with IDs |
+| `stats()` | `GET /v1/stats` | Database statistics |
+
+### Single and bulk lookups
+
+Pass a bare domain — `claude.ai`, not `https://claude.ai/chat`. Subdomains resolve to their registrable domain, so `chat.openai.com` returns the classification for `openai.com`. Both found and not-found responses are HTTP 200; your integration checks one unambiguous `in_blocklist` boolean instead of distinguishing "not found" from "bad request."
+
+```python
+report = client.bulk_lookup(["openai.com", "github.com", "notion.so"])
+for row in report["results"]:
+    print(row["domain"], row["in_blocklist"], row.get("primary_category"))
+
+# For arbitrarily large inputs, chunking is handled for you:
+everything = client.bulk_lookup_all(my_10000_domains)
+```
+
+### Loading and synchronizing the full list
+
+For a local cache, DNS sinkhole, or firewall External Dynamic List, stream the full classified list. `iter_domains()` walks cursor-based pagination transparently:
+
+```python
+with open("ai_blocklist.txt", "w") as fh:
+    for record in client.iter_domains(status="active", min_confidence=0.9):
+        fh.write(record["domain"] + "\n")
+```
+
+Then keep it current with a daily delta sync instead of re-downloading everything:
+
+```python
+changes = client.delta(since="2026-07-01T00:00:00Z")
+for added in changes["added"]:
+    local_set.add(added["domain"])
+for removed in changes["removed"]:
+    local_set.discard(removed["domain"])
+```
+
+This "full load once, delta forever" pattern lets a modest request quota back millions of local lookups, because the actual matching happens in your own Redis, SQLite, or flat file.
+
+### Error handling
+
+The client raises a small, specific exception hierarchy so callers can react precisely:
+
+```python
+from aitoolsblocklist import (
+    AIToolsBlocklistError, AuthenticationError,
+    RateLimitError, NotFoundError,
+)
+
+try:
+    result = client.lookup("example.com")
+except AuthenticationError:
+    ...   # 401/403 — rotate or renew the key
+except RateLimitError:
+    ...   # 429 after retries — back off or upgrade the plan
+except AIToolsBlocklistError:
+    ...   # any other API or network failure
+```
+
+The client is also a context manager, so the underlying HTTP session is cleaned up automatically:
+
+```python
+with AIToolsBlocklistClient("atb_your_api_key_here") as client:
+    print(client.stats())
+```
+
+---
+
+## Why domain-level AI classification is needed
+
+The technical interface above solves a problem that has become urgent for nearly every organization that runs a network: **you can no longer see, let alone govern, where your data goes when employees and students use AI tools.**
+
+Two years ago, "AI at work" meant a handful of well-known services. Today, thousands of AI products launch every month, each with its own domain, and each capable of receiving text, code, images, or documents that a user pastes in. A blanket firewall rule cannot keep up, and a hand-maintained list of the famous fifty tools is stale within a week. The result is *shadow AI*: unsanctioned tools processing sensitive information with no oversight. Surveys of enterprise security leaders consistently rank data exposure through generative AI among their fastest-growing risks, and the guidance emerging from public research institutions reflects the same concern.
+
+### The data-governance problem
+
+When an employee pastes a customer contract into an unfamiliar AI summarizer, or a developer sends proprietary source code to an online "explain this function" tool, that data leaves the organization's control. It may be logged, used for model training, or retained indefinitely. This is not a hypothetical: the U.S. National Institute of Standards and Technology's [AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework) explicitly identifies data confidentiality and third-party dependency as core risks to be mapped and managed, and encourages organizations to maintain an inventory of the AI systems their people actually use. You cannot inventory what you cannot see, and you cannot see AI-tool usage at the network layer without knowing which of the millions of domains crossing your egress are AI tools in the first place.
+
+Foundational work on the risks of large-scale models — for example, research hosted on [arXiv](https://arxiv.org/) from academic and industry labs — has documented how readily these systems memorize and can surface training data, which is precisely why unsanctioned data submission matters. Domain-level classification is the practical control point: it turns an unbounded, ever-changing population of AI services into a queryable list your existing security stack can act on.
+
+### Education and duty of care
+
+Schools face a sharper version of the same problem, layered on top of legal obligations. In the United States, districts that receive certain federal funding must operate a technology protection measure under the Children's Internet Protection Act — the [Federal Communications Commission's CIPA guidance](https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act) sets out the requirement. AI chatbots, essay generators, and deepfake tools complicate that duty enormously: a district may want to *permit* an approved AI tutor that supports learning while *blocking* an essay-writing service that undermines academic integrity, or a companion-chat app inappropriate for minors. A single "AI" category cannot express that policy; per-subcategory classification can.
+
+Academic-integrity offices are grappling with the same distinction. University teaching-and-learning centers — such as the guidance published by [Stanford University](https://www.stanford.edu/) and other institutions on generative AI in coursework — increasingly frame the question not as "AI or no AI" but as "which uses of which tools are appropriate for which assignments." Enforcing a nuanced policy at the network level requires data that is equally nuanced.
+
+### Why a purpose-built, refreshed feed
+
+General web-categorization databases were not designed for this. They answer "is this a shopping site, a news site, a social network?" — not "is this an AI code assistant, an AI voice cloner, or an AI research agent?" The pace is also different: general categories are stable for years, whereas AI tools appear and disappear weekly. The dataset behind this client is rebuilt daily precisely so that new tools are caught close to launch rather than months later, and it is organized around the functional distinctions that policy actually turns on.
+
+The public-interest research community has long argued that transparency and classification are prerequisites for governing new technologies. Digital-rights organizations such as the [Electronic Frontier Foundation](https://www.eff.org/) emphasize that filtering and monitoring must be precise and accountable rather than blunt — and precision is exactly what per-category domain intelligence enables. A well-classified feed lets an administrator write a rule that blocks a genuine risk category without collaterally breaking legitimate, sanctioned tools, which is the difference between a policy people follow and one they route around.
+
+### Where this package fits
+
+This library is the thin, reliable bridge between that intelligence and your own systems. Drop `lookup()` into a proxy plugin or SOAR playbook for real-time decisions; use `iter_domains()` to seed a DNS sinkhole or firewall EDL; run `delta()` on a nightly cron to stay current. Because the heavy matching runs locally against data you have already synced, the approach scales from a single script to millions of lookups a day without hammering the API.
+
+If AI-tool visibility and control are on your roadmap — for security, for compliance, or for duty of care — the [AI Tools Blocklist](https://www.aitoolsblocklist.com) provides the data, and this package provides the Python integration.
+
+---
+
+## Links
+
+- Product and API documentation: [https://www.aitoolsblocklist.com](https://www.aitoolsblocklist.com)
+- NIST AI Risk Management Framework: [https://www.nist.gov/itl/ai-risk-management-framework](https://www.nist.gov/itl/ai-risk-management-framework)
+- FCC — Children's Internet Protection Act: [https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act](https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act)
+- arXiv (open-access research): [https://arxiv.org/](https://arxiv.org/)
+
+## License
+
+MIT

aitoolsblocklist-1.0.0/aitoolsblocklist/__init__.py

@@ -0,0 +1,25 @@
+"""
+aitoolsblocklist — Python client for the AI Tools Blocklist API.
+
+A small, dependency-light wrapper around the REST API at
+https://www.aitoolsblocklist.com that lets security, networking and
+compliance teams look up, filter, and synchronize classified AI-tool
+domains from Python.
+"""
+
+from .client import (
+    AIToolsBlocklistClient,
+    AIToolsBlocklistError,
+    AuthenticationError,
+    RateLimitError,
+    NotFoundError,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "AIToolsBlocklistClient",
+    "AIToolsBlocklistError",
+    "AuthenticationError",
+    "RateLimitError",
+    "NotFoundError",
+]

aitoolsblocklist-1.0.0/aitoolsblocklist/client.py

@@ -0,0 +1,243 @@
+"""
+AI Tools Blocklist API client.
+
+Wraps the REST endpoints documented at
+https://www.aitoolsblocklist.com/ai-blocklist-api.php:
+
+    GET  /v1/lookup/{domain}   single domain classification
+    GET  /v1/domains           full classified list with filters
+    GET  /v1/delta             changes since a timestamp
+    POST /v1/bulk-lookup       classify up to 1,000 domains
+    GET  /v1/taxonomy          category tree
+    GET  /v1/stats             database statistics
+
+Only the standard library and ``requests`` are required.
+"""
+
+import time
+from typing import Dict, Iterator, List, Optional
+
+import requests
+
+DEFAULT_BASE_URL = "https://api.aitoolsblocklist.com/v1"
+DEFAULT_TIMEOUT = 30
+USER_AGENT = "aitoolsblocklist-python/1.0.0 (+https://www.aitoolsblocklist.com)"
+
+
+class AIToolsBlocklistError(Exception):
+    """Base exception for all client errors."""
+
+
+class AuthenticationError(AIToolsBlocklistError):
+    """Raised on 401/403 — missing, invalid, expired or revoked API key."""
+
+
+class RateLimitError(AIToolsBlocklistError):
+    """Raised on 429 — request quota exceeded for the current plan."""
+
+
+class NotFoundError(AIToolsBlocklistError):
+    """Raised on 404 — resource or endpoint not found."""
+
+
+class AIToolsBlocklistClient:
+    """
+    Client for the AI Tools Blocklist API.
+
+    Args:
+        api_key: Your ``atb_`` API key from the account dashboard.
+        base_url: Override the API base URL (useful for testing).
+        timeout: Per-request timeout in seconds.
+        max_retries: Automatic retries on 429 / 5xx with backoff.
+
+    Example:
+        >>> from aitoolsblocklist import AIToolsBlocklistClient
+        >>> client = AIToolsBlocklistClient("atb_your_api_key_here")
+        >>> result = client.lookup("claude.ai")
+        >>> result["in_blocklist"]
+        True
+        >>> result["primary_category"]
+        'Text & Language'
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = DEFAULT_TIMEOUT,
+        max_retries: int = 3,
+    ):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._session = requests.Session()
+        self._session.headers.update(
+            {
+                "Authorization": f"Bearer {api_key}",
+                "Accept": "application/json",
+                "Accept-Encoding": "gzip",
+                "User-Agent": USER_AGENT,
+            }
+        )
+
+    # ---- internal request helper -------------------------------------
+
+    def _request(self, method: str, path: str, **kwargs) -> Dict:
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        last_exc = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = self._session.request(method, url, timeout=self.timeout, **kwargs)
+            except requests.RequestException as exc:  # network-level errors
+                last_exc = exc
+                if attempt < self.max_retries:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise AIToolsBlocklistError(f"Request to {url} failed: {exc}") from exc
+
+            if resp.status_code in (200, 201):
+                return resp.json()
+            if resp.status_code == 401:
+                raise AuthenticationError(self._msg(resp, "Invalid or missing API key."))
+            if resp.status_code == 403:
+                raise AuthenticationError(self._msg(resp, "API key revoked or plan does not include this endpoint."))
+            if resp.status_code == 404:
+                raise NotFoundError(self._msg(resp, "Resource not found."))
+            if resp.status_code == 429:
+                if attempt < self.max_retries:
+                    retry_after = int(resp.headers.get("Retry-After", 2 ** attempt))
+                    time.sleep(retry_after)
+                    continue
+                raise RateLimitError(self._msg(resp, "Rate limit exceeded."))
+            if resp.status_code >= 500:
+                if attempt < self.max_retries:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise AIToolsBlocklistError(self._msg(resp, "Server error."))
+            raise AIToolsBlocklistError(self._msg(resp, f"Unexpected status {resp.status_code}."))
+        raise AIToolsBlocklistError(f"Request failed after retries: {last_exc}")
+
+    @staticmethod
+    def _msg(resp: requests.Response, default: str) -> str:
+        try:
+            body = resp.json()
+            return body.get("message") or body.get("error") or default
+        except ValueError:
+            return default
+
+    # ---- public API --------------------------------------------------
+
+    def lookup(self, domain: str) -> Dict:
+        """
+        Classify a single domain.
+
+        Pass the bare domain (``claude.ai``), not a URL. Subdomains resolve
+        to their registrable domain, so ``chat.openai.com`` returns the
+        classification for ``openai.com``. Both found and not-found return
+        HTTP 200; check the ``in_blocklist`` boolean.
+        """
+        domain = self._clean_domain(domain)
+        return self._request("GET", f"/lookup/{domain}")
+
+    def is_blocked(self, domain: str) -> bool:
+        """Convenience helper returning just the ``in_blocklist`` boolean."""
+        return bool(self.lookup(domain).get("in_blocklist", False))
+
+    def bulk_lookup(self, domains: List[str]) -> Dict:
+        """
+        Classify up to 1,000 domains in a single request. For larger inputs,
+        use :meth:`bulk_lookup_all`, which chunks automatically.
+        """
+        if len(domains) > 1000:
+            raise ValueError("bulk_lookup accepts at most 1000 domains; use bulk_lookup_all().")
+        cleaned = [self._clean_domain(d) for d in domains]
+        return self._request("POST", "/bulk-lookup", json={"domains": cleaned})
+
+    def bulk_lookup_all(self, domains: List[str]) -> List[Dict]:
+        """Classify any number of domains by chunking into 1,000-item calls."""
+        results: List[Dict] = []
+        for i in range(0, len(domains), 1000):
+            chunk = domains[i : i + 1000]
+            resp = self.bulk_lookup(chunk)
+            results.extend(resp.get("results", resp.get("domains", [])))
+        return results
+
+    def domains(
+        self,
+        category: Optional[str] = None,
+        min_confidence: Optional[float] = None,
+        risk_tier: Optional[str] = None,
+        status: Optional[str] = None,
+        cursor: Optional[str] = None,
+    ) -> Dict:
+        """
+        Return one page of the classified domain list. Supports filtering by
+        ``category``, ``min_confidence``, ``risk_tier`` and ``status``, and
+        cursor-based pagination. For the entire list, use :meth:`iter_domains`.
+        """
+        params = {}
+        if category:
+            params["category"] = category
+        if min_confidence is not None:
+            params["min_confidence"] = min_confidence
+        if risk_tier:
+            params["risk_tier"] = risk_tier
+        if status:
+            params["status"] = status
+        if cursor:
+            params["cursor"] = cursor
+        return self._request("GET", "/domains", params=params)
+
+    def iter_domains(self, **filters) -> Iterator[Dict]:
+        """
+        Yield every domain record matching ``filters``, transparently walking
+        cursor-based pagination. Ideal for loading a local cache, DNS
+        sinkhole, or firewall External Dynamic List.
+        """
+        cursor = None
+        while True:
+            page = self.domains(cursor=cursor, **filters)
+            for record in page.get("domains", []):
+                yield record
+            cursor = page.get("next_cursor")
+            if not cursor:
+                break
+
+    def delta(self, since: str) -> Dict:
+        """
+        Return additions, changes and removals since an ISO-8601 timestamp.
+        Run this on a daily cron to keep a local copy current without
+        re-downloading the full list.
+        """
+        return self._request("GET", "/delta", params={"since": since})
+
+    def taxonomy(self) -> Dict:
+        """Return the category tree (18 functional categories and their subcategories)."""
+        return self._request("GET", "/taxonomy")
+
+    def stats(self) -> Dict:
+        """Return database statistics: total domains, per-category counts, last refresh."""
+        return self._request("GET", "/stats")
+
+    # ---- helpers -----------------------------------------------------
+
+    @staticmethod
+    def _clean_domain(domain: str) -> str:
+        d = domain.strip().lower()
+        for prefix in ("https://", "http://"):
+            if d.startswith(prefix):
+                d = d[len(prefix):]
+        d = d.split("/")[0].split("?")[0]
+        return d
+
+    def close(self) -> None:
+        self._session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()

aitoolsblocklist-1.0.0/aitoolsblocklist.egg-info/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.1
+Name: aitoolsblocklist
+Version: 1.0.0
+Summary: Python client for the AI Tools Blocklist API — classified AI-tool domains for web filtering, DNS security, and DLP.
+Home-page: https://www.aitoolsblocklist.com
+Author: Alpha Quantum
+Author-email: info@alpha-quantum.com
+License: MIT
+Project-URL: Homepage, https://www.aitoolsblocklist.com
+Project-URL: API Documentation, https://www.aitoolsblocklist.com/ai-blocklist-api.php
+Project-URL: Source, https://www.aitoolsblocklist.com
+Description: # aitoolsblocklist
+        
+        A lightweight, production-ready Python client for the [AI Tools Blocklist API](https://www.aitoolsblocklist.com) — a daily-refreshed database of classified AI-tool domains built for web filtering, DNS security, data-loss prevention, and acceptable-use enforcement. The package wraps the REST API in a small, typed, dependency-light interface so security engineers, network administrators, and compliance teams can look up, filter, and synchronize AI-tool domain intelligence directly from Python.
+        
+        The underlying dataset is a specialized extraction from a 102-million-domain enterprise web filtering infrastructure. It contains tens of thousands of AI-tool domains — chatbots, code assistants, image and video generators, voice-cloning services, autonomous agents, AI companions, and more — each classified into functional categories and subcategories rather than a single flat "AI" label. That granularity is what makes per-category policy possible: permit an approved AI tutor while blocking a deepfake generator, or allow a coding assistant while flagging an unvetted document-processing service.
+        
+        ---
+        
+        ## Installation
+        
+        ```bash
+        pip install aitoolsblocklist
+        ```
+        
+        The only runtime dependency is [`requests`](https://requests.readthedocs.io/). Python 3.7 and newer are supported.
+        
+        ## Quick start
+        
+        ```python
+        from aitoolsblocklist import AIToolsBlocklistClient
+        
+        client = AIToolsBlocklistClient("atb_your_api_key_here")
+        
+        # Single lookup — is this domain an AI tool, and what kind?
+        result = client.lookup("claude.ai")
+        print(result["in_blocklist"])        # True
+        print(result["primary_category"])    # "Text & Language"
+        print(result["subcategory"])         # "General assistants & chatbots"
+        print(result["risk_tier"])           # "high"
+        
+        # A convenience boolean for policy gates
+        if client.is_blocked("midjourney.com"):
+            enforce_block_policy("midjourney.com")
+        ```
+        
+        An API key is required and is available from the account dashboard after subscribing to any paid plan. Keys use the `atb_` prefix for easy identification in logs, and are passed automatically as a Bearer token on every request.
+        
+        ## Technical overview
+        
+        ### Authentication and configuration
+        
+        The client sends your key in the `Authorization: Bearer` header, requests gzip-compressed responses, and sets a descriptive `User-Agent`. Construction takes a handful of options:
+        
+        ```python
+        client = AIToolsBlocklistClient(
+            api_key="atb_your_api_key_here",
+            base_url="https://api.aitoolsblocklist.com/v1",  # override for testing
+            timeout=30,        # per-request timeout, seconds
+            max_retries=3,     # automatic backoff on 429 and 5xx
+        )
+        ```
+        
+        Transient failures — HTTP 429 rate limits and 5xx server errors — are retried automatically with exponential backoff, honoring the `Retry-After` header when present. Authentication problems raise immediately, because retrying a revoked key is pointless.
+        
+        ### Endpoints and methods
+        
+        Each REST endpoint maps to a single method:
+        
+        | Method | Endpoint | Purpose |
+        | --- | --- | --- |
+        | `lookup(domain)` | `GET /v1/lookup/{domain}` | Classify one domain |
+        | `is_blocked(domain)` | — | Convenience boolean wrapper |
+        | `bulk_lookup(domains)` | `POST /v1/bulk-lookup` | Classify up to 1,000 domains |
+        | `bulk_lookup_all(domains)` | — | Auto-chunks any number of domains |
+        | `domains(**filters)` | `GET /v1/domains` | One filtered, paginated page |
+        | `iter_domains(**filters)` | — | Iterate the entire filtered list |
+        | `delta(since)` | `GET /v1/delta` | Changes since a timestamp |
+        | `taxonomy()` | `GET /v1/taxonomy` | Category tree with IDs |
+        | `stats()` | `GET /v1/stats` | Database statistics |
+        
+        ### Single and bulk lookups
+        
+        Pass a bare domain — `claude.ai`, not `https://claude.ai/chat`. Subdomains resolve to their registrable domain, so `chat.openai.com` returns the classification for `openai.com`. Both found and not-found responses are HTTP 200; your integration checks one unambiguous `in_blocklist` boolean instead of distinguishing "not found" from "bad request."
+        
+        ```python
+        report = client.bulk_lookup(["openai.com", "github.com", "notion.so"])
+        for row in report["results"]:
+            print(row["domain"], row["in_blocklist"], row.get("primary_category"))
+        
+        # For arbitrarily large inputs, chunking is handled for you:
+        everything = client.bulk_lookup_all(my_10000_domains)
+        ```
+        
+        ### Loading and synchronizing the full list
+        
+        For a local cache, DNS sinkhole, or firewall External Dynamic List, stream the full classified list. `iter_domains()` walks cursor-based pagination transparently:
+        
+        ```python
+        with open("ai_blocklist.txt", "w") as fh:
+            for record in client.iter_domains(status="active", min_confidence=0.9):
+                fh.write(record["domain"] + "\n")
+        ```
+        
+        Then keep it current with a daily delta sync instead of re-downloading everything:
+        
+        ```python
+        changes = client.delta(since="2026-07-01T00:00:00Z")
+        for added in changes["added"]:
+            local_set.add(added["domain"])
+        for removed in changes["removed"]:
+            local_set.discard(removed["domain"])
+        ```
+        
+        This "full load once, delta forever" pattern lets a modest request quota back millions of local lookups, because the actual matching happens in your own Redis, SQLite, or flat file.
+        
+        ### Error handling
+        
+        The client raises a small, specific exception hierarchy so callers can react precisely:
+        
+        ```python
+        from aitoolsblocklist import (
+            AIToolsBlocklistError, AuthenticationError,
+            RateLimitError, NotFoundError,
+        )
+        
+        try:
+            result = client.lookup("example.com")
+        except AuthenticationError:
+            ...   # 401/403 — rotate or renew the key
+        except RateLimitError:
+            ...   # 429 after retries — back off or upgrade the plan
+        except AIToolsBlocklistError:
+            ...   # any other API or network failure
+        ```
+        
+        The client is also a context manager, so the underlying HTTP session is cleaned up automatically:
+        
+        ```python
+        with AIToolsBlocklistClient("atb_your_api_key_here") as client:
+            print(client.stats())
+        ```
+        
+        ---
+        
+        ## Why domain-level AI classification is needed
+        
+        The technical interface above solves a problem that has become urgent for nearly every organization that runs a network: **you can no longer see, let alone govern, where your data goes when employees and students use AI tools.**
+        
+        Two years ago, "AI at work" meant a handful of well-known services. Today, thousands of AI products launch every month, each with its own domain, and each capable of receiving text, code, images, or documents that a user pastes in. A blanket firewall rule cannot keep up, and a hand-maintained list of the famous fifty tools is stale within a week. The result is *shadow AI*: unsanctioned tools processing sensitive information with no oversight. Surveys of enterprise security leaders consistently rank data exposure through generative AI among their fastest-growing risks, and the guidance emerging from public research institutions reflects the same concern.
+        
+        ### The data-governance problem
+        
+        When an employee pastes a customer contract into an unfamiliar AI summarizer, or a developer sends proprietary source code to an online "explain this function" tool, that data leaves the organization's control. It may be logged, used for model training, or retained indefinitely. This is not a hypothetical: the U.S. National Institute of Standards and Technology's [AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework) explicitly identifies data confidentiality and third-party dependency as core risks to be mapped and managed, and encourages organizations to maintain an inventory of the AI systems their people actually use. You cannot inventory what you cannot see, and you cannot see AI-tool usage at the network layer without knowing which of the millions of domains crossing your egress are AI tools in the first place.
+        
+        Foundational work on the risks of large-scale models — for example, research hosted on [arXiv](https://arxiv.org/) from academic and industry labs — has documented how readily these systems memorize and can surface training data, which is precisely why unsanctioned data submission matters. Domain-level classification is the practical control point: it turns an unbounded, ever-changing population of AI services into a queryable list your existing security stack can act on.
+        
+        ### Education and duty of care
+        
+        Schools face a sharper version of the same problem, layered on top of legal obligations. In the United States, districts that receive certain federal funding must operate a technology protection measure under the Children's Internet Protection Act — the [Federal Communications Commission's CIPA guidance](https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act) sets out the requirement. AI chatbots, essay generators, and deepfake tools complicate that duty enormously: a district may want to *permit* an approved AI tutor that supports learning while *blocking* an essay-writing service that undermines academic integrity, or a companion-chat app inappropriate for minors. A single "AI" category cannot express that policy; per-subcategory classification can.
+        
+        Academic-integrity offices are grappling with the same distinction. University teaching-and-learning centers — such as the guidance published by [Stanford University](https://www.stanford.edu/) and other institutions on generative AI in coursework — increasingly frame the question not as "AI or no AI" but as "which uses of which tools are appropriate for which assignments." Enforcing a nuanced policy at the network level requires data that is equally nuanced.
+        
+        ### Why a purpose-built, refreshed feed
+        
+        General web-categorization databases were not designed for this. They answer "is this a shopping site, a news site, a social network?" — not "is this an AI code assistant, an AI voice cloner, or an AI research agent?" The pace is also different: general categories are stable for years, whereas AI tools appear and disappear weekly. The dataset behind this client is rebuilt daily precisely so that new tools are caught close to launch rather than months later, and it is organized around the functional distinctions that policy actually turns on.
+        
+        The public-interest research community has long argued that transparency and classification are prerequisites for governing new technologies. Digital-rights organizations such as the [Electronic Frontier Foundation](https://www.eff.org/) emphasize that filtering and monitoring must be precise and accountable rather than blunt — and precision is exactly what per-category domain intelligence enables. A well-classified feed lets an administrator write a rule that blocks a genuine risk category without collaterally breaking legitimate, sanctioned tools, which is the difference between a policy people follow and one they route around.
+        
+        ### Where this package fits
+        
+        This library is the thin, reliable bridge between that intelligence and your own systems. Drop `lookup()` into a proxy plugin or SOAR playbook for real-time decisions; use `iter_domains()` to seed a DNS sinkhole or firewall EDL; run `delta()` on a nightly cron to stay current. Because the heavy matching runs locally against data you have already synced, the approach scales from a single script to millions of lookups a day without hammering the API.
+        
+        If AI-tool visibility and control are on your roadmap — for security, for compliance, or for duty of care — the [AI Tools Blocklist](https://www.aitoolsblocklist.com) provides the data, and this package provides the Python integration.
+        
+        ---
+        
+        ## Links
+        
+        - Product and API documentation: [https://www.aitoolsblocklist.com](https://www.aitoolsblocklist.com)
+        - NIST AI Risk Management Framework: [https://www.nist.gov/itl/ai-risk-management-framework](https://www.nist.gov/itl/ai-risk-management-framework)
+        - FCC — Children's Internet Protection Act: [https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act](https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act)
+        - arXiv (open-access research): [https://arxiv.org/](https://arxiv.org/)
+        
+        ## License
+        
+        MIT
+        
+Keywords: ai tools blocklist,web filtering,dns filtering,content filtering,ai domain classification,shadow ai,data loss prevention,dlp,cipa,acceptable use policy,ai governance,domain categorization
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Networking :: Firewalls
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown

aitoolsblocklist-1.0.0/aitoolsblocklist.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+aitoolsblocklist/__init__.py
+aitoolsblocklist/client.py
+aitoolsblocklist.egg-info/PKG-INFO
+aitoolsblocklist.egg-info/SOURCES.txt
+aitoolsblocklist.egg-info/dependency_links.txt
+aitoolsblocklist.egg-info/requires.txt
+aitoolsblocklist.egg-info/top_level.txt

aitoolsblocklist-1.0.0/aitoolsblocklist.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aitoolsblocklist-1.0.0/aitoolsblocklist.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.20.0

aitoolsblocklist-1.0.0/aitoolsblocklist.egg-info/top_level.txt

@@ -0,0 +1 @@
+aitoolsblocklist

aitoolsblocklist-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aitoolsblocklist-1.0.0/setup.py

@@ -0,0 +1,46 @@
+import pathlib
+from setuptools import setup, find_packages
+
+HERE = pathlib.Path(__file__).parent
+README = (HERE / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="aitoolsblocklist",
+    version="1.0.0",
+    description="Python client for the AI Tools Blocklist API — classified AI-tool domains for web filtering, DNS security, and DLP.",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    author="Alpha Quantum",
+    author_email="info@alpha-quantum.com",
+    url="https://www.aitoolsblocklist.com",
+    project_urls={
+        "Homepage": "https://www.aitoolsblocklist.com",
+        "API Documentation": "https://www.aitoolsblocklist.com/ai-blocklist-api.php",
+        "Source": "https://www.aitoolsblocklist.com",
+    },
+    license="MIT",
+    packages=find_packages(exclude=("tests", "test")),
+    python_requires=">=3.7",
+    install_requires=["requests>=2.20.0"],
+    keywords=[
+        "ai tools blocklist", "web filtering", "dns filtering", "content filtering",
+        "ai domain classification", "shadow ai", "data loss prevention", "dlp",
+        "cipa", "acceptable use policy", "ai governance", "domain categorization",
+    ],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Information Technology",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Internet :: Proxy Servers",
+        "Topic :: Security",
+        "Topic :: System :: Networking :: Firewalls",
+    ],
+)