selldatatoai 1.0.0__tar.gz

selldatatoai-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.

selldatatoai-1.0.0/MANIFEST.in

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

selldatatoai-1.0.0/PKG-INFO

@@ -0,0 +1,317 @@
+Metadata-Version: 2.1
+Name: selldatatoai
+Version: 1.0.0
+Summary: Python client for the Data Asset Score API from selldatatoai.com: score company domains 0 to 100 for the data AI buyers want, one at a time or in batches of 100.
+Home-page: https://www.selldatatoai.com
+Author: Alpha Quantum
+Author-email: info@alpha-quantum.com
+License: MIT
+Project-URL: Homepage, https://www.selldatatoai.com
+Project-URL: Documentation, https://www.selldatatoai.com/api/
+Project-URL: Source, https://github.com/explainableaixai/selldatatoai-python
+Project-URL: Pricing, https://www.selldatatoai.com/pricing/
+Project-URL: Demo, https://www.selldatatoai.com/data-asset-score/
+Keywords: sell data to ai,data asset score,ai training data,ai data broker,company data api,lead scoring,firmographics,technographics,data licensing,b2b data,domain intelligence
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20
+
+# selldatatoai for Python
+
+`selldatatoai` scores companies for AI data deals from Python. You pass a website; the API answers with a 0 to 100 [Data Asset Score](https://www.selldatatoai.com/data-asset-score/), a grade, the data the company likely holds and how long it has been online.
+
+```bash
+pip install selldatatoai
+```
+
+Requires Python 3.7 or newer and `requests`. The package also installs a `selldatatoai` command for scoring a text file of domains into a CSV.
+
+The service behind it is [selldatatoai.com](https://www.selldatatoai.com/), which keeps an index of 102 million domains, 99.99% of the active internet, together with each domain's history.
+
+## Who this is for
+
+- **Data brokers** who source data partners for AI labs and need to know which companies are worth a call.
+- **Data companies** that resell records and want to rank prospects by the data they hold.
+- **Referral partners** in data programs who screen companies before they introduce them.
+- **Analysts** who study which sectors hold the operational records that AI training buys.
+
+If you are new to the trade itself, the step-by-step guide on [how to sell data to AI companies](https://www.selldatatoai.com/how-to-sell-data-to-ai-companies/) covers the deal from first contact to delivery.
+
+## Five lines to a score
+
+```python
+import os
+from selldatatoai import DataAssetScoreClient
+
+client = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+s = client.score("example.com")
+print(s["data_asset_score"], s["grade"], [a["label"] for a in s["likely_data_assets"]])
+```
+
+The result is a plain `dict` with the API field names. A trimmed real answer looks like this:
+
+```json
+{
+  "domain": "promega.com",
+  "data_asset_score": 88,
+  "grade": "A",
+  "status": "active",
+  "verified_active": true,
+  "iab_category": "Business and Finance > Industries > Pharmaceutical Industry",
+  "country": "United States",
+  "history": {"first_seen_year": 1993, "years_online": 33, "founded_year": null, "pre_ai_years": 30},
+  "pre_ai_archive_likely": true,
+  "data_systems": [
+    {"system": "Jira / Confluence", "data_type": "Work tickets and internal wiki", "type": "work_tickets"},
+    {"system": "Webex", "data_type": "Calls and meetings", "type": "calls"}
+  ],
+  "likely_data_assets": [
+    {"type": "support_tickets", "label": "Support tickets and chat transcripts"},
+    {"type": "knowledge_base", "label": "Knowledge base, SOPs and documentation"}
+  ],
+  "data_coverage": "full",
+  "cached": true
+}
+```
+
+## API surface
+
+| Python call | Endpoint | Cost |
+|---|---|---|
+| `client.score(domain)` | `GET /api/v1/score` | 1 lookup |
+| `client.submit_batch(domains)` | `POST /api/v1/score/batch` | 1 lookup per valid, unique domain |
+| `client.get_batch(batch_id)` | `GET /api/v1/score/batch?id=` | free |
+| `client.wait_for_batch(batch_id, interval=5, max_wait=300)` | polls `get_batch` | free |
+| `client.score_many(domains, interval=5, max_wait=300, on_batch=None)` | batches of 100 | 1 lookup per valid, unique domain |
+| `client.usage()` | `GET /api/v1/usage` | free |
+
+Constructor:
+
+```python
+DataAssetScoreClient(api_key, base_url="https://www.selldatatoai.com/api/v1", timeout=60, session=None)
+```
+
+Pass your own `requests.Session` if you need retries, a proxy or connection pooling shared with other code. The key travels in the `X-API-Key` header only.
+
+Every field is described in the [REST API reference](https://www.selldatatoai.com/api/).
+
+## Handling failures
+
+All HTTP errors raise `SellDataToAIError`. It carries `.status` (HTTP code), `.code` (the API error string) and `.body` (the decoded answer).
+
+```python
+from selldatatoai import SellDataToAIError
+
+def safe_score(client, domain):
+    try:
+        return client.score(domain)
+    except SellDataToAIError as e:
+        if e.code == "invalid_domain":
+            return None                      # bad input, skip it
+        if e.code == "monthly_limit_reached":
+            raise SystemExit("Out of lookups until the 1st (UTC)")
+        raise                                # 401, network trouble, anything else
+```
+
+Codes you can meet:
+
+- `missing_api_key`, `invalid_api_key` (401): no key, or the plan is not active.
+- `invalid_domain` (400): not a valid domain.
+- `no_domains`, `too_many_domains` (400): a batch needs 1 to 100 entries.
+- `monthly_limit_reached` (429): limits reset on the first day of each month, UTC.
+- `batch_busy` (429): three of your batches are still open.
+- `batch_not_found` (404): unknown id, or older than 7 days.
+- `not_available` (410): company lists are not served by the API.
+
+## Recipes
+
+### Recipe 1: score a spreadsheet with pandas
+
+```python
+import os
+import pandas as pd
+from selldatatoai import DataAssetScoreClient
+
+client = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+df = pd.read_csv("prospects.csv")                    # needs a 'website' column
+
+items = client.score_many(df["website"].dropna().tolist())
+rows = []
+for it in items:
+    r = it.get("result") or {}
+    rows.append({
+        "website": it["input"],
+        "score": r.get("data_asset_score"),
+        "grade": r.get("grade"),
+        "status": r.get("status", it["status"]),
+        "pre_ai_years": (r.get("history") or {}).get("pre_ai_years"),
+        "systems": ", ".join(s["system"] for s in r.get("data_systems", [])),
+    })
+
+scored = df.merge(pd.DataFrame(rows), on="website", how="left")
+scored.sort_values("score", ascending=False).to_csv("prospects_scored.csv", index=False)
+```
+
+### Recipe 2: a FastAPI route for a partner form
+
+```python
+import os
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from selldatatoai import DataAssetScoreClient, SellDataToAIError
+
+app = FastAPI()
+sda = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+
+class Signup(BaseModel):
+    company: str
+    website: str
+
+@app.post("/signup")
+def signup(body: Signup):
+    try:
+        s = sda.score(body.website)
+    except SellDataToAIError as e:
+        if e.status == 400:
+            raise HTTPException(422, "That website does not look valid")
+        raise HTTPException(503, "Scoring is unavailable, try again shortly")
+    tier = "priority" if s["grade"] in ("A", "B") and s["verified_active"] else "standard"
+    return {"company": body.company, "tier": tier, "score": s["data_asset_score"]}
+```
+
+The client is synchronous. Inside an async framework, FastAPI runs plain `def` routes in a thread pool, which is what you want here.
+
+### Recipe 3: parallel single lookups with a thread pool
+
+Batches are the better tool for big lists. For a few dozen domains where you want each answer as soon as it is ready, a small pool works well:
+
+```python
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+domains = ["example-one.com", "example-two.com", "example-three.com"]
+with ThreadPoolExecutor(max_workers=4) as pool:
+    futures = {pool.submit(client.score, d): d for d in domains}
+    for f in as_completed(futures):
+        d = futures[f]
+        try:
+            print(d, f.result()["data_asset_score"])
+        except SellDataToAIError as e:
+            print(d, "failed:", e.code)
+```
+
+Keep the pool small. Each worker is one open request, and every call still counts against your monthly lookups.
+
+### Recipe 4: the command line
+
+```bash
+export SDA_API_KEY=xxxx
+selldatatoai score example.com          # JSON for one company
+selldatatoai usage                      # plan and remaining lookups
+selldatatoai file domains.txt out.csv   # one domain per line, '#' lines skipped
+```
+
+`python -m selldatatoai` works the same way if the script directory is not on your `PATH`. The CSV has one row per input line, in input order, with score, grade, company status, years online, pre-AI years, systems and likely data assets.
+
+## How batches behave
+
+1. You send up to 100 domains.
+2. Lookups are charged right away: one per valid, unique domain.
+3. Domains scored in the last 30 days are `done` in the first answer.
+4. The rest finish in the background, usually within a minute.
+5. You poll with the batch id. Polling is free.
+6. Results stay in the order you sent and are kept for 7 days.
+
+You can hold three open batches per key. `score_many` sends them one after another, so it never trips that limit.
+
+## Making sense of the numbers
+
+The score gathers several factor groups into one number. The [how the Data Asset Score works](https://www.selldatatoai.com/how-the-data-asset-score-works/) page describes the data behind each group. The exact weights are not published.
+
+A few reading tips:
+
+- **Grade first, score second.** Two companies at 71 and 74 are in the same band. A and B grades are where most buyers start.
+- **Check `status`.** A high score on a `winding_down_or_acquired` company means the records may still exist, but the seller has changed.
+- **Look at `pre_ai_years`.** Records written before 2023 are free of AI-generated text, which some buyers value highly.
+- **Read `data_coverage`.** `limited` means fewer signals were available, so the score is less certain.
+
+Sector context helps too. Life sciences companies tend to hold lab, study and R&D records, which is why buyers of [AI training data companies](https://www.selldatatoai.com/ai-training-data-companies/) research often start with that sector. A ready file of the top 3,000 US firms in that space is described on the [list of biotech companies](https://www.selldatatoai.com/list-of-biotech-companies/) page.
+
+## Grouping companies by the data they hold
+
+Buyers rarely ask for "data". They ask for a type: support conversations, engineering tickets, recorded calls, contracts, design files. The `type` keys in `data_systems` and `likely_data_assets` let you build those groups in a few lines.
+
+```python
+from collections import defaultdict
+
+by_type = defaultdict(list)
+for it in items:                                   # items from score_many()
+    r = it.get("result")
+    if not r or not r["verified_active"]:
+        continue
+    for a in r["likely_data_assets"]:
+        by_type[a["type"]].append((r["data_asset_score"], r["domain"]))
+
+for t, rows in sorted(by_type.items()):
+    top = sorted(rows, reverse=True)[:10]
+    print(t, len(rows), "companies, top:", ", ".join(d for _, d in top))
+```
+
+Two keys deserve a note:
+
+- `data_systems` lists systems the company is seen to run, each mapped to the data type it stores. It is the stronger signal, because a running system means the records exist and can be exported.
+- `likely_data_assets` lists what the company probably holds based on its sector and footprint. Use it to widen a search, not to promise a buyer anything.
+
+When a buyer asks for one data type across a whole market, the website also sells ready lists by data type next to the sector lists.
+
+## Plans
+
+Paid plans only, from $99 a month: Basic $99 for 5,000 lookups, Pro $299 for 25,000 with batch scoring, Scale $799 for 100,000 with batch scoring. The website demo allows 5 checks a day if you want to see the output before you subscribe. Your key appears in your dashboard as soon as the payment completes.
+
+Company lists are not part of any API plan. They are one-time files of the top 3,000 US companies per sector, from $249 a list, delivered by email links that work for 30 days.
+
+## FAQ
+
+### What does the selldatatoai package do?
+
+The selldatatoai package is the Python client for the Data Asset Score API at selldatatoai.com. It scores a company website from 0 to 100 for the data AI buyers want and returns the grade, status, data systems, likely data assets and web history.
+
+### Does it support asyncio?
+
+Not directly. Run calls in a thread pool (`asyncio.to_thread` on Python 3.9+) or use the batch endpoint, which does the parallel work on the server.
+
+### What counts as a lookup?
+
+Each scored domain, fresh or cached. A batch counts each valid, unique domain once. Usage and polling calls are free.
+
+### Can I pass full URLs?
+
+Yes. `https://www.example.com/contact` and `example.com` score the same company.
+
+### Are results stored?
+
+A result is reused for 30 days, then the domain is scored again. Batches are deleted after 7 days.
+
+### Is there a sandbox key?
+
+No. Plans are paid, and the demo on the website is the only free access.
+
+## Links
+
+- Homepage: https://www.selldatatoai.com/
+- Source code: https://github.com/explainableaixai/selldatatoai-python
+- Python packaging guide: [packaging.python.org](https://packaging.python.org/en/latest/tutorials/installing-packages/)
+- Thread pools in the standard library: [docs.python.org](https://docs.python.org/3/library/concurrent.futures.html)
+
+## License
+
+MIT, Copyright (c) 2026 Alpha Quantum. Questions: info@alpha-quantum.com

selldatatoai-1.0.0/README.md

@@ -0,0 +1,289 @@
+# selldatatoai for Python
+
+`selldatatoai` scores companies for AI data deals from Python. You pass a website; the API answers with a 0 to 100 [Data Asset Score](https://www.selldatatoai.com/data-asset-score/), a grade, the data the company likely holds and how long it has been online.
+
+```bash
+pip install selldatatoai
+```
+
+Requires Python 3.7 or newer and `requests`. The package also installs a `selldatatoai` command for scoring a text file of domains into a CSV.
+
+The service behind it is [selldatatoai.com](https://www.selldatatoai.com/), which keeps an index of 102 million domains, 99.99% of the active internet, together with each domain's history.
+
+## Who this is for
+
+- **Data brokers** who source data partners for AI labs and need to know which companies are worth a call.
+- **Data companies** that resell records and want to rank prospects by the data they hold.
+- **Referral partners** in data programs who screen companies before they introduce them.
+- **Analysts** who study which sectors hold the operational records that AI training buys.
+
+If you are new to the trade itself, the step-by-step guide on [how to sell data to AI companies](https://www.selldatatoai.com/how-to-sell-data-to-ai-companies/) covers the deal from first contact to delivery.
+
+## Five lines to a score
+
+```python
+import os
+from selldatatoai import DataAssetScoreClient
+
+client = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+s = client.score("example.com")
+print(s["data_asset_score"], s["grade"], [a["label"] for a in s["likely_data_assets"]])
+```
+
+The result is a plain `dict` with the API field names. A trimmed real answer looks like this:
+
+```json
+{
+  "domain": "promega.com",
+  "data_asset_score": 88,
+  "grade": "A",
+  "status": "active",
+  "verified_active": true,
+  "iab_category": "Business and Finance > Industries > Pharmaceutical Industry",
+  "country": "United States",
+  "history": {"first_seen_year": 1993, "years_online": 33, "founded_year": null, "pre_ai_years": 30},
+  "pre_ai_archive_likely": true,
+  "data_systems": [
+    {"system": "Jira / Confluence", "data_type": "Work tickets and internal wiki", "type": "work_tickets"},
+    {"system": "Webex", "data_type": "Calls and meetings", "type": "calls"}
+  ],
+  "likely_data_assets": [
+    {"type": "support_tickets", "label": "Support tickets and chat transcripts"},
+    {"type": "knowledge_base", "label": "Knowledge base, SOPs and documentation"}
+  ],
+  "data_coverage": "full",
+  "cached": true
+}
+```
+
+## API surface
+
+| Python call | Endpoint | Cost |
+|---|---|---|
+| `client.score(domain)` | `GET /api/v1/score` | 1 lookup |
+| `client.submit_batch(domains)` | `POST /api/v1/score/batch` | 1 lookup per valid, unique domain |
+| `client.get_batch(batch_id)` | `GET /api/v1/score/batch?id=` | free |
+| `client.wait_for_batch(batch_id, interval=5, max_wait=300)` | polls `get_batch` | free |
+| `client.score_many(domains, interval=5, max_wait=300, on_batch=None)` | batches of 100 | 1 lookup per valid, unique domain |
+| `client.usage()` | `GET /api/v1/usage` | free |
+
+Constructor:
+
+```python
+DataAssetScoreClient(api_key, base_url="https://www.selldatatoai.com/api/v1", timeout=60, session=None)
+```
+
+Pass your own `requests.Session` if you need retries, a proxy or connection pooling shared with other code. The key travels in the `X-API-Key` header only.
+
+Every field is described in the [REST API reference](https://www.selldatatoai.com/api/).
+
+## Handling failures
+
+All HTTP errors raise `SellDataToAIError`. It carries `.status` (HTTP code), `.code` (the API error string) and `.body` (the decoded answer).
+
+```python
+from selldatatoai import SellDataToAIError
+
+def safe_score(client, domain):
+    try:
+        return client.score(domain)
+    except SellDataToAIError as e:
+        if e.code == "invalid_domain":
+            return None                      # bad input, skip it
+        if e.code == "monthly_limit_reached":
+            raise SystemExit("Out of lookups until the 1st (UTC)")
+        raise                                # 401, network trouble, anything else
+```
+
+Codes you can meet:
+
+- `missing_api_key`, `invalid_api_key` (401): no key, or the plan is not active.
+- `invalid_domain` (400): not a valid domain.
+- `no_domains`, `too_many_domains` (400): a batch needs 1 to 100 entries.
+- `monthly_limit_reached` (429): limits reset on the first day of each month, UTC.
+- `batch_busy` (429): three of your batches are still open.
+- `batch_not_found` (404): unknown id, or older than 7 days.
+- `not_available` (410): company lists are not served by the API.
+
+## Recipes
+
+### Recipe 1: score a spreadsheet with pandas
+
+```python
+import os
+import pandas as pd
+from selldatatoai import DataAssetScoreClient
+
+client = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+df = pd.read_csv("prospects.csv")                    # needs a 'website' column
+
+items = client.score_many(df["website"].dropna().tolist())
+rows = []
+for it in items:
+    r = it.get("result") or {}
+    rows.append({
+        "website": it["input"],
+        "score": r.get("data_asset_score"),
+        "grade": r.get("grade"),
+        "status": r.get("status", it["status"]),
+        "pre_ai_years": (r.get("history") or {}).get("pre_ai_years"),
+        "systems": ", ".join(s["system"] for s in r.get("data_systems", [])),
+    })
+
+scored = df.merge(pd.DataFrame(rows), on="website", how="left")
+scored.sort_values("score", ascending=False).to_csv("prospects_scored.csv", index=False)
+```
+
+### Recipe 2: a FastAPI route for a partner form
+
+```python
+import os
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from selldatatoai import DataAssetScoreClient, SellDataToAIError
+
+app = FastAPI()
+sda = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+
+class Signup(BaseModel):
+    company: str
+    website: str
+
+@app.post("/signup")
+def signup(body: Signup):
+    try:
+        s = sda.score(body.website)
+    except SellDataToAIError as e:
+        if e.status == 400:
+            raise HTTPException(422, "That website does not look valid")
+        raise HTTPException(503, "Scoring is unavailable, try again shortly")
+    tier = "priority" if s["grade"] in ("A", "B") and s["verified_active"] else "standard"
+    return {"company": body.company, "tier": tier, "score": s["data_asset_score"]}
+```
+
+The client is synchronous. Inside an async framework, FastAPI runs plain `def` routes in a thread pool, which is what you want here.
+
+### Recipe 3: parallel single lookups with a thread pool
+
+Batches are the better tool for big lists. For a few dozen domains where you want each answer as soon as it is ready, a small pool works well:
+
+```python
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+domains = ["example-one.com", "example-two.com", "example-three.com"]
+with ThreadPoolExecutor(max_workers=4) as pool:
+    futures = {pool.submit(client.score, d): d for d in domains}
+    for f in as_completed(futures):
+        d = futures[f]
+        try:
+            print(d, f.result()["data_asset_score"])
+        except SellDataToAIError as e:
+            print(d, "failed:", e.code)
+```
+
+Keep the pool small. Each worker is one open request, and every call still counts against your monthly lookups.
+
+### Recipe 4: the command line
+
+```bash
+export SDA_API_KEY=xxxx
+selldatatoai score example.com          # JSON for one company
+selldatatoai usage                      # plan and remaining lookups
+selldatatoai file domains.txt out.csv   # one domain per line, '#' lines skipped
+```
+
+`python -m selldatatoai` works the same way if the script directory is not on your `PATH`. The CSV has one row per input line, in input order, with score, grade, company status, years online, pre-AI years, systems and likely data assets.
+
+## How batches behave
+
+1. You send up to 100 domains.
+2. Lookups are charged right away: one per valid, unique domain.
+3. Domains scored in the last 30 days are `done` in the first answer.
+4. The rest finish in the background, usually within a minute.
+5. You poll with the batch id. Polling is free.
+6. Results stay in the order you sent and are kept for 7 days.
+
+You can hold three open batches per key. `score_many` sends them one after another, so it never trips that limit.
+
+## Making sense of the numbers
+
+The score gathers several factor groups into one number. The [how the Data Asset Score works](https://www.selldatatoai.com/how-the-data-asset-score-works/) page describes the data behind each group. The exact weights are not published.
+
+A few reading tips:
+
+- **Grade first, score second.** Two companies at 71 and 74 are in the same band. A and B grades are where most buyers start.
+- **Check `status`.** A high score on a `winding_down_or_acquired` company means the records may still exist, but the seller has changed.
+- **Look at `pre_ai_years`.** Records written before 2023 are free of AI-generated text, which some buyers value highly.
+- **Read `data_coverage`.** `limited` means fewer signals were available, so the score is less certain.
+
+Sector context helps too. Life sciences companies tend to hold lab, study and R&D records, which is why buyers of [AI training data companies](https://www.selldatatoai.com/ai-training-data-companies/) research often start with that sector. A ready file of the top 3,000 US firms in that space is described on the [list of biotech companies](https://www.selldatatoai.com/list-of-biotech-companies/) page.
+
+## Grouping companies by the data they hold
+
+Buyers rarely ask for "data". They ask for a type: support conversations, engineering tickets, recorded calls, contracts, design files. The `type` keys in `data_systems` and `likely_data_assets` let you build those groups in a few lines.
+
+```python
+from collections import defaultdict
+
+by_type = defaultdict(list)
+for it in items:                                   # items from score_many()
+    r = it.get("result")
+    if not r or not r["verified_active"]:
+        continue
+    for a in r["likely_data_assets"]:
+        by_type[a["type"]].append((r["data_asset_score"], r["domain"]))
+
+for t, rows in sorted(by_type.items()):
+    top = sorted(rows, reverse=True)[:10]
+    print(t, len(rows), "companies, top:", ", ".join(d for _, d in top))
+```
+
+Two keys deserve a note:
+
+- `data_systems` lists systems the company is seen to run, each mapped to the data type it stores. It is the stronger signal, because a running system means the records exist and can be exported.
+- `likely_data_assets` lists what the company probably holds based on its sector and footprint. Use it to widen a search, not to promise a buyer anything.
+
+When a buyer asks for one data type across a whole market, the website also sells ready lists by data type next to the sector lists.
+
+## Plans
+
+Paid plans only, from $99 a month: Basic $99 for 5,000 lookups, Pro $299 for 25,000 with batch scoring, Scale $799 for 100,000 with batch scoring. The website demo allows 5 checks a day if you want to see the output before you subscribe. Your key appears in your dashboard as soon as the payment completes.
+
+Company lists are not part of any API plan. They are one-time files of the top 3,000 US companies per sector, from $249 a list, delivered by email links that work for 30 days.
+
+## FAQ
+
+### What does the selldatatoai package do?
+
+The selldatatoai package is the Python client for the Data Asset Score API at selldatatoai.com. It scores a company website from 0 to 100 for the data AI buyers want and returns the grade, status, data systems, likely data assets and web history.
+
+### Does it support asyncio?
+
+Not directly. Run calls in a thread pool (`asyncio.to_thread` on Python 3.9+) or use the batch endpoint, which does the parallel work on the server.
+
+### What counts as a lookup?
+
+Each scored domain, fresh or cached. A batch counts each valid, unique domain once. Usage and polling calls are free.
+
+### Can I pass full URLs?
+
+Yes. `https://www.example.com/contact` and `example.com` score the same company.
+
+### Are results stored?
+
+A result is reused for 30 days, then the domain is scored again. Batches are deleted after 7 days.
+
+### Is there a sandbox key?
+
+No. Plans are paid, and the demo on the website is the only free access.
+
+## Links
+
+- Homepage: https://www.selldatatoai.com/
+- Source code: https://github.com/explainableaixai/selldatatoai-python
+- Python packaging guide: [packaging.python.org](https://packaging.python.org/en/latest/tutorials/installing-packages/)
+- Thread pools in the standard library: [docs.python.org](https://docs.python.org/3/library/concurrent.futures.html)
+
+## License
+
+MIT, Copyright (c) 2026 Alpha Quantum. Questions: info@alpha-quantum.com

selldatatoai-1.0.0/selldatatoai/__init__.py

@@ -0,0 +1,5 @@
+"""selldatatoai: Python client for the Data Asset Score API (https://www.selldatatoai.com/api/)."""
+from .client import BATCH_MAX, VERSION, DataAssetScoreClient, SellDataToAIError
+
+__version__ = VERSION
+__all__ = ["DataAssetScoreClient", "SellDataToAIError", "BATCH_MAX", "__version__"]

selldatatoai-1.0.0/selldatatoai/__main__.py

@@ -0,0 +1,64 @@
+"""python -m selldatatoai score example.com | python -m selldatatoai file domains.txt out.csv | python -m selldatatoai usage
+
+The key is read from the SDA_API_KEY environment variable.
+"""
+import csv
+import json
+import os
+import sys
+
+from .client import DataAssetScoreClient, SellDataToAIError
+
+FIELDS = ["input", "domain", "status", "data_asset_score", "grade", "company_status", "verified_active",
+          "iab_category", "country", "years_online", "pre_ai_years", "data_systems", "likely_data_assets"]
+
+
+def _row(item):
+    r = item.get("result") or {}
+    h = r.get("history") or {}
+    return {
+        "input": item.get("input"), "domain": item.get("domain"), "status": item.get("status"),
+        "data_asset_score": r.get("data_asset_score"), "grade": r.get("grade"), "company_status": r.get("status"),
+        "verified_active": r.get("verified_active"), "iab_category": r.get("iab_category"), "country": r.get("country"),
+        "years_online": h.get("years_online"), "pre_ai_years": h.get("pre_ai_years"),
+        "data_systems": "; ".join(s["system"] for s in r.get("data_systems") or []),
+        "likely_data_assets": "; ".join(a["label"] for a in r.get("likely_data_assets") or []),
+    }
+
+
+def main(argv):
+    key = os.environ.get("SDA_API_KEY")
+    if not key or len(argv) < 1:
+        print(__doc__)
+        return 2
+    c = DataAssetScoreClient(key)
+    try:
+        if argv[0] == "score" and len(argv) > 1:
+            print(json.dumps(c.score(argv[1]), indent=2))
+        elif argv[0] == "usage":
+            print(json.dumps(c.usage(), indent=2))
+        elif argv[0] == "file" and len(argv) > 2:
+            with open(argv[1], encoding="utf-8") as f:
+                domains = [l.strip() for l in f if l.strip() and not l.startswith("#")]
+            items = c.score_many(domains, on_batch=lambda b: print("batch %s done" % b["id"], file=sys.stderr))
+            with open(argv[2], "w", newline="", encoding="utf-8") as f:
+                w = csv.DictWriter(f, fieldnames=FIELDS)
+                w.writeheader()
+                for it in items:
+                    w.writerow(_row(it))
+            print("wrote %d rows to %s" % (len(items), argv[2]))
+        else:
+            print(__doc__)
+            return 2
+    except SellDataToAIError as e:
+        print("error %s %s: %s" % (e.status, e.code, e), file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
+
+
+def _entry():
+    sys.exit(main(sys.argv[1:]))

selldatatoai-1.0.0/selldatatoai/client.py

@@ -0,0 +1,88 @@
+"""Client for the Data Asset Score API at https://www.selldatatoai.com/api/"""
+import time
+
+import requests
+
+__all__ = ["DataAssetScoreClient", "SellDataToAIError", "BATCH_MAX"]
+
+VERSION = "1.0.0"
+DEFAULT_BASE = "https://www.selldatatoai.com/api/v1"
+USER_AGENT = "selldatatoai-python/%s (+https://www.selldatatoai.com)" % VERSION
+BATCH_MAX = 100
+
+
+class SellDataToAIError(Exception):
+    """Raised for any non-2xx answer. `status` is the HTTP code, `code` the API error string."""
+
+    def __init__(self, status, code=None, message=None, body=None):
+        super().__init__(message or code or "HTTP %s" % status)
+        self.status = status
+        self.code = code
+        self.body = body
+
+
+class DataAssetScoreClient:
+    def __init__(self, api_key, base_url=DEFAULT_BASE, timeout=60, session=None):
+        if not api_key:
+            raise ValueError("An API key is required. Plans: https://www.selldatatoai.com/pricing/")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = session or requests.Session()
+        self.session.headers.update({"X-API-Key": api_key, "User-Agent": USER_AGENT, "Accept": "application/json"})
+
+    def _request(self, method, path, params=None, json=None):
+        r = self.session.request(method, self.base_url + path, params=params, json=json, timeout=self.timeout)
+        try:
+            data = r.json()
+        except ValueError:
+            data = None
+        if 200 <= r.status_code < 300 and data is not None:
+            return data
+        code = data.get("error") if isinstance(data, dict) else None
+        msg = data.get("message") if isinstance(data, dict) else None
+        raise SellDataToAIError(r.status_code, code, msg or "HTTP %s" % r.status_code, data if data is not None else r.text)
+
+    def score(self, domain):
+        """Score one company domain. Full URLs are accepted."""
+        if not domain:
+            raise ValueError("domain is required")
+        return self._request("GET", "/score", params={"domain": str(domain).strip()})
+
+    def submit_batch(self, domains):
+        """Submit up to 100 domains; returns the batch dict (id, status, results...)."""
+        domains = list(domains)
+        if not domains:
+            raise ValueError("domains must not be empty")
+        if len(domains) > BATCH_MAX:
+            raise ValueError("a batch takes at most %d domains" % BATCH_MAX)
+        return self._request("POST", "/score/batch", json={"domains": domains})
+
+    def get_batch(self, batch_id):
+        """Poll a batch. Polling does not use lookups."""
+        return self._request("GET", "/score/batch", params={"id": batch_id})
+
+    def wait_for_batch(self, batch_id, interval=5, max_wait=300):
+        start = time.time()
+        while True:
+            b = self.get_batch(batch_id)
+            if b.get("status") == "done":
+                return b
+            if time.time() - start > max_wait:
+                raise SellDataToAIError(0, "batch_timeout", "batch %s still processing after %ss" % (batch_id, max_wait), b)
+            time.sleep(interval)
+
+    def score_many(self, domains, interval=5, max_wait=300, on_batch=None):
+        """Score any number of domains in batches of 100; returns result items in input order."""
+        domains = list(domains)
+        out = []
+        for i in range(0, len(domains), BATCH_MAX):
+            sent = self.submit_batch(domains[i:i + BATCH_MAX])
+            done = sent if sent.get("status") == "done" else self.wait_for_batch(sent["id"], interval, max_wait)
+            out.extend(done["results"])
+            if on_batch:
+                on_batch(done)
+        return out
+
+    def usage(self):
+        """Plan, lookups used this month and lookups remaining."""
+        return self._request("GET", "/usage")

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

@@ -0,0 +1,317 @@
+Metadata-Version: 2.1
+Name: selldatatoai
+Version: 1.0.0
+Summary: Python client for the Data Asset Score API from selldatatoai.com: score company domains 0 to 100 for the data AI buyers want, one at a time or in batches of 100.
+Home-page: https://www.selldatatoai.com
+Author: Alpha Quantum
+Author-email: info@alpha-quantum.com
+License: MIT
+Project-URL: Homepage, https://www.selldatatoai.com
+Project-URL: Documentation, https://www.selldatatoai.com/api/
+Project-URL: Source, https://github.com/explainableaixai/selldatatoai-python
+Project-URL: Pricing, https://www.selldatatoai.com/pricing/
+Project-URL: Demo, https://www.selldatatoai.com/data-asset-score/
+Keywords: sell data to ai,data asset score,ai training data,ai data broker,company data api,lead scoring,firmographics,technographics,data licensing,b2b data,domain intelligence
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20
+
+# selldatatoai for Python
+
+`selldatatoai` scores companies for AI data deals from Python. You pass a website; the API answers with a 0 to 100 [Data Asset Score](https://www.selldatatoai.com/data-asset-score/), a grade, the data the company likely holds and how long it has been online.
+
+```bash
+pip install selldatatoai
+```
+
+Requires Python 3.7 or newer and `requests`. The package also installs a `selldatatoai` command for scoring a text file of domains into a CSV.
+
+The service behind it is [selldatatoai.com](https://www.selldatatoai.com/), which keeps an index of 102 million domains, 99.99% of the active internet, together with each domain's history.
+
+## Who this is for
+
+- **Data brokers** who source data partners for AI labs and need to know which companies are worth a call.
+- **Data companies** that resell records and want to rank prospects by the data they hold.
+- **Referral partners** in data programs who screen companies before they introduce them.
+- **Analysts** who study which sectors hold the operational records that AI training buys.
+
+If you are new to the trade itself, the step-by-step guide on [how to sell data to AI companies](https://www.selldatatoai.com/how-to-sell-data-to-ai-companies/) covers the deal from first contact to delivery.
+
+## Five lines to a score
+
+```python
+import os
+from selldatatoai import DataAssetScoreClient
+
+client = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+s = client.score("example.com")
+print(s["data_asset_score"], s["grade"], [a["label"] for a in s["likely_data_assets"]])
+```
+
+The result is a plain `dict` with the API field names. A trimmed real answer looks like this:
+
+```json
+{
+  "domain": "promega.com",
+  "data_asset_score": 88,
+  "grade": "A",
+  "status": "active",
+  "verified_active": true,
+  "iab_category": "Business and Finance > Industries > Pharmaceutical Industry",
+  "country": "United States",
+  "history": {"first_seen_year": 1993, "years_online": 33, "founded_year": null, "pre_ai_years": 30},
+  "pre_ai_archive_likely": true,
+  "data_systems": [
+    {"system": "Jira / Confluence", "data_type": "Work tickets and internal wiki", "type": "work_tickets"},
+    {"system": "Webex", "data_type": "Calls and meetings", "type": "calls"}
+  ],
+  "likely_data_assets": [
+    {"type": "support_tickets", "label": "Support tickets and chat transcripts"},
+    {"type": "knowledge_base", "label": "Knowledge base, SOPs and documentation"}
+  ],
+  "data_coverage": "full",
+  "cached": true
+}
+```
+
+## API surface
+
+| Python call | Endpoint | Cost |
+|---|---|---|
+| `client.score(domain)` | `GET /api/v1/score` | 1 lookup |
+| `client.submit_batch(domains)` | `POST /api/v1/score/batch` | 1 lookup per valid, unique domain |
+| `client.get_batch(batch_id)` | `GET /api/v1/score/batch?id=` | free |
+| `client.wait_for_batch(batch_id, interval=5, max_wait=300)` | polls `get_batch` | free |
+| `client.score_many(domains, interval=5, max_wait=300, on_batch=None)` | batches of 100 | 1 lookup per valid, unique domain |
+| `client.usage()` | `GET /api/v1/usage` | free |
+
+Constructor:
+
+```python
+DataAssetScoreClient(api_key, base_url="https://www.selldatatoai.com/api/v1", timeout=60, session=None)
+```
+
+Pass your own `requests.Session` if you need retries, a proxy or connection pooling shared with other code. The key travels in the `X-API-Key` header only.
+
+Every field is described in the [REST API reference](https://www.selldatatoai.com/api/).
+
+## Handling failures
+
+All HTTP errors raise `SellDataToAIError`. It carries `.status` (HTTP code), `.code` (the API error string) and `.body` (the decoded answer).
+
+```python
+from selldatatoai import SellDataToAIError
+
+def safe_score(client, domain):
+    try:
+        return client.score(domain)
+    except SellDataToAIError as e:
+        if e.code == "invalid_domain":
+            return None                      # bad input, skip it
+        if e.code == "monthly_limit_reached":
+            raise SystemExit("Out of lookups until the 1st (UTC)")
+        raise                                # 401, network trouble, anything else
+```
+
+Codes you can meet:
+
+- `missing_api_key`, `invalid_api_key` (401): no key, or the plan is not active.
+- `invalid_domain` (400): not a valid domain.
+- `no_domains`, `too_many_domains` (400): a batch needs 1 to 100 entries.
+- `monthly_limit_reached` (429): limits reset on the first day of each month, UTC.
+- `batch_busy` (429): three of your batches are still open.
+- `batch_not_found` (404): unknown id, or older than 7 days.
+- `not_available` (410): company lists are not served by the API.
+
+## Recipes
+
+### Recipe 1: score a spreadsheet with pandas
+
+```python
+import os
+import pandas as pd
+from selldatatoai import DataAssetScoreClient
+
+client = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+df = pd.read_csv("prospects.csv")                    # needs a 'website' column
+
+items = client.score_many(df["website"].dropna().tolist())
+rows = []
+for it in items:
+    r = it.get("result") or {}
+    rows.append({
+        "website": it["input"],
+        "score": r.get("data_asset_score"),
+        "grade": r.get("grade"),
+        "status": r.get("status", it["status"]),
+        "pre_ai_years": (r.get("history") or {}).get("pre_ai_years"),
+        "systems": ", ".join(s["system"] for s in r.get("data_systems", [])),
+    })
+
+scored = df.merge(pd.DataFrame(rows), on="website", how="left")
+scored.sort_values("score", ascending=False).to_csv("prospects_scored.csv", index=False)
+```
+
+### Recipe 2: a FastAPI route for a partner form
+
+```python
+import os
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from selldatatoai import DataAssetScoreClient, SellDataToAIError
+
+app = FastAPI()
+sda = DataAssetScoreClient(os.environ["SDA_API_KEY"])
+
+class Signup(BaseModel):
+    company: str
+    website: str
+
+@app.post("/signup")
+def signup(body: Signup):
+    try:
+        s = sda.score(body.website)
+    except SellDataToAIError as e:
+        if e.status == 400:
+            raise HTTPException(422, "That website does not look valid")
+        raise HTTPException(503, "Scoring is unavailable, try again shortly")
+    tier = "priority" if s["grade"] in ("A", "B") and s["verified_active"] else "standard"
+    return {"company": body.company, "tier": tier, "score": s["data_asset_score"]}
+```
+
+The client is synchronous. Inside an async framework, FastAPI runs plain `def` routes in a thread pool, which is what you want here.
+
+### Recipe 3: parallel single lookups with a thread pool
+
+Batches are the better tool for big lists. For a few dozen domains where you want each answer as soon as it is ready, a small pool works well:
+
+```python
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+domains = ["example-one.com", "example-two.com", "example-three.com"]
+with ThreadPoolExecutor(max_workers=4) as pool:
+    futures = {pool.submit(client.score, d): d for d in domains}
+    for f in as_completed(futures):
+        d = futures[f]
+        try:
+            print(d, f.result()["data_asset_score"])
+        except SellDataToAIError as e:
+            print(d, "failed:", e.code)
+```
+
+Keep the pool small. Each worker is one open request, and every call still counts against your monthly lookups.
+
+### Recipe 4: the command line
+
+```bash
+export SDA_API_KEY=xxxx
+selldatatoai score example.com          # JSON for one company
+selldatatoai usage                      # plan and remaining lookups
+selldatatoai file domains.txt out.csv   # one domain per line, '#' lines skipped
+```
+
+`python -m selldatatoai` works the same way if the script directory is not on your `PATH`. The CSV has one row per input line, in input order, with score, grade, company status, years online, pre-AI years, systems and likely data assets.
+
+## How batches behave
+
+1. You send up to 100 domains.
+2. Lookups are charged right away: one per valid, unique domain.
+3. Domains scored in the last 30 days are `done` in the first answer.
+4. The rest finish in the background, usually within a minute.
+5. You poll with the batch id. Polling is free.
+6. Results stay in the order you sent and are kept for 7 days.
+
+You can hold three open batches per key. `score_many` sends them one after another, so it never trips that limit.
+
+## Making sense of the numbers
+
+The score gathers several factor groups into one number. The [how the Data Asset Score works](https://www.selldatatoai.com/how-the-data-asset-score-works/) page describes the data behind each group. The exact weights are not published.
+
+A few reading tips:
+
+- **Grade first, score second.** Two companies at 71 and 74 are in the same band. A and B grades are where most buyers start.
+- **Check `status`.** A high score on a `winding_down_or_acquired` company means the records may still exist, but the seller has changed.
+- **Look at `pre_ai_years`.** Records written before 2023 are free of AI-generated text, which some buyers value highly.
+- **Read `data_coverage`.** `limited` means fewer signals were available, so the score is less certain.
+
+Sector context helps too. Life sciences companies tend to hold lab, study and R&D records, which is why buyers of [AI training data companies](https://www.selldatatoai.com/ai-training-data-companies/) research often start with that sector. A ready file of the top 3,000 US firms in that space is described on the [list of biotech companies](https://www.selldatatoai.com/list-of-biotech-companies/) page.
+
+## Grouping companies by the data they hold
+
+Buyers rarely ask for "data". They ask for a type: support conversations, engineering tickets, recorded calls, contracts, design files. The `type` keys in `data_systems` and `likely_data_assets` let you build those groups in a few lines.
+
+```python
+from collections import defaultdict
+
+by_type = defaultdict(list)
+for it in items:                                   # items from score_many()
+    r = it.get("result")
+    if not r or not r["verified_active"]:
+        continue
+    for a in r["likely_data_assets"]:
+        by_type[a["type"]].append((r["data_asset_score"], r["domain"]))
+
+for t, rows in sorted(by_type.items()):
+    top = sorted(rows, reverse=True)[:10]
+    print(t, len(rows), "companies, top:", ", ".join(d for _, d in top))
+```
+
+Two keys deserve a note:
+
+- `data_systems` lists systems the company is seen to run, each mapped to the data type it stores. It is the stronger signal, because a running system means the records exist and can be exported.
+- `likely_data_assets` lists what the company probably holds based on its sector and footprint. Use it to widen a search, not to promise a buyer anything.
+
+When a buyer asks for one data type across a whole market, the website also sells ready lists by data type next to the sector lists.
+
+## Plans
+
+Paid plans only, from $99 a month: Basic $99 for 5,000 lookups, Pro $299 for 25,000 with batch scoring, Scale $799 for 100,000 with batch scoring. The website demo allows 5 checks a day if you want to see the output before you subscribe. Your key appears in your dashboard as soon as the payment completes.
+
+Company lists are not part of any API plan. They are one-time files of the top 3,000 US companies per sector, from $249 a list, delivered by email links that work for 30 days.
+
+## FAQ
+
+### What does the selldatatoai package do?
+
+The selldatatoai package is the Python client for the Data Asset Score API at selldatatoai.com. It scores a company website from 0 to 100 for the data AI buyers want and returns the grade, status, data systems, likely data assets and web history.
+
+### Does it support asyncio?
+
+Not directly. Run calls in a thread pool (`asyncio.to_thread` on Python 3.9+) or use the batch endpoint, which does the parallel work on the server.
+
+### What counts as a lookup?
+
+Each scored domain, fresh or cached. A batch counts each valid, unique domain once. Usage and polling calls are free.
+
+### Can I pass full URLs?
+
+Yes. `https://www.example.com/contact` and `example.com` score the same company.
+
+### Are results stored?
+
+A result is reused for 30 days, then the domain is scored again. Batches are deleted after 7 days.
+
+### Is there a sandbox key?
+
+No. Plans are paid, and the demo on the website is the only free access.
+
+## Links
+
+- Homepage: https://www.selldatatoai.com/
+- Source code: https://github.com/explainableaixai/selldatatoai-python
+- Python packaging guide: [packaging.python.org](https://packaging.python.org/en/latest/tutorials/installing-packages/)
+- Thread pools in the standard library: [docs.python.org](https://docs.python.org/3/library/concurrent.futures.html)
+
+## License
+
+MIT, Copyright (c) 2026 Alpha Quantum. Questions: info@alpha-quantum.com

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

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+selldatatoai/__init__.py
+selldatatoai/__main__.py
+selldatatoai/client.py
+selldatatoai.egg-info/PKG-INFO
+selldatatoai.egg-info/SOURCES.txt
+selldatatoai.egg-info/dependency_links.txt
+selldatatoai.egg-info/entry_points.txt
+selldatatoai.egg-info/requires.txt
+selldatatoai.egg-info/top_level.txt
+tests/test_client.py

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

@@ -0,0 +1 @@
+

selldatatoai-1.0.0/selldatatoai.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+selldatatoai = selldatatoai.__main__:_entry

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

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

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

@@ -0,0 +1 @@
+selldatatoai

selldatatoai-1.0.0/setup.cfg

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

selldatatoai-1.0.0/setup.py

@@ -0,0 +1,40 @@
+import pathlib
+from setuptools import setup, find_packages
+
+README = (pathlib.Path(__file__).parent / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="selldatatoai",
+    version="1.0.0",
+    description="Python client for the Data Asset Score API from selldatatoai.com: score company domains 0 to 100 for the data AI buyers want, one at a time or in batches of 100.",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    author="Alpha Quantum",
+    author_email="info@alpha-quantum.com",
+    url="https://www.selldatatoai.com",
+    project_urls={
+        "Homepage": "https://www.selldatatoai.com",
+        "Documentation": "https://www.selldatatoai.com/api/",
+        "Source": "https://github.com/explainableaixai/selldatatoai-python",
+        "Pricing": "https://www.selldatatoai.com/pricing/",
+        "Demo": "https://www.selldatatoai.com/data-asset-score/",
+    },
+    license="MIT",
+    packages=find_packages(exclude=("tests", "test")),
+    install_requires=["requests>=2.20"],
+    python_requires=">=3.7",
+    entry_points={"console_scripts": ["selldatatoai=selldatatoai.__main__:_entry"]},
+    keywords=["sell data to ai", "data asset score", "ai training data", "ai data broker", "company data api",
+              "lead scoring", "firmographics", "technographics", "data licensing", "b2b data", "domain intelligence"],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Internet :: WWW/HTTP",
+        "Topic :: Office/Business",
+    ],
+)

selldatatoai-1.0.0/tests/test_client.py

@@ -0,0 +1,82 @@
+import json
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, urlparse
+
+from selldatatoai import DataAssetScoreClient, SellDataToAIError
+
+RESULT = {"domain": "example-labs.com", "data_asset_score": 82, "grade": "A", "status": "active"}
+
+
+class Stub(BaseHTTPRequestHandler):
+    polls = 0
+
+    def log_message(self, *a):
+        pass
+
+    def _send(self, code, obj):
+        b = json.dumps(obj).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(b)))
+        self.end_headers()
+        self.wfile.write(b)
+
+    def do_GET(self):
+        u = urlparse(self.path)
+        q = parse_qs(u.query)
+        if self.headers.get("X-API-Key") != "k":
+            return self._send(401, {"error": "invalid_api_key"})
+        if u.path == "/v1/score":
+            if q.get("domain") == ["bad"]:
+                return self._send(400, {"error": "invalid_domain", "message": "Pass a domain"})
+            return self._send(200, RESULT)
+        if u.path == "/v1/usage":
+            return self._send(200, {"plan": "pro", "remaining": 7})
+        if u.path == "/v1/score/batch":
+            Stub.polls += 1
+            if Stub.polls < 2:
+                return self._send(200, {"id": "b_1", "status": "processing", "results": []})
+            return self._send(200, {"id": "b_1", "status": "done", "results": [{"input": "a.com", "status": "done", "result": RESULT}]})
+        self._send(404, {"error": "unknown_endpoint"})
+
+    def do_POST(self):
+        n = int(self.headers.get("Content-Length", 0))
+        body = json.loads(self.rfile.read(n))
+        self._send(202, {"id": "b_1", "status": "processing", "total": len(body["domains"]), "results": []})
+
+
+class ClientTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.srv = HTTPServer(("127.0.0.1", 0), Stub)
+        threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
+        cls.base = "http://127.0.0.1:%d/v1" % cls.srv.server_port
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.srv.shutdown()
+
+    def test_score_usage(self):
+        c = DataAssetScoreClient("k", base_url=self.base)
+        self.assertEqual(c.score("example-labs.com")["grade"], "A")
+        self.assertEqual(c.usage()["remaining"], 7)
+
+    def test_errors(self):
+        c = DataAssetScoreClient("k", base_url=self.base)
+        with self.assertRaises(SellDataToAIError) as e:
+            c.score("bad")
+        self.assertEqual((e.exception.status, e.exception.code), (400, "invalid_domain"))
+        with self.assertRaises(SellDataToAIError) as e:
+            DataAssetScoreClient("x", base_url=self.base).usage()
+        self.assertEqual(e.exception.status, 401)
+
+    def test_score_many(self):
+        c = DataAssetScoreClient("k", base_url=self.base)
+        items = c.score_many(["a.com"], interval=0.01)
+        self.assertEqual(items[0]["result"]["data_asset_score"], 82)
+
+
+if __name__ == "__main__":
+    unittest.main()