dataify-sdk 1.0.0__tar.gz → 1.1.0__tar.gz

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: dataify-sdk
-Version: 1.0.0
+Version: 1.1.0
 Summary: Python SDK that calls the Dataify upstream REST API directly (no MCP layer) — web scrapers and search engines.
 Project-URL: Homepage, https://dashboard.dataify.com
 Project-URL: Repository, https://github.com/dataify/dataify-sdk
@@ -31,7 +31,7 @@ Python 客户端库，**直接调用** [Dataify](https://dashboard.dataify.com)
 ## 功能
 
 - 🔍 **搜索引擎** — Google（17 种）、Bing（6 种）、Yandex、DuckDuckGo，走 `POST /request`
-- 🛒 **平台抓取器** — Amazon、YouTube、TikTok、Facebook、Instagram、Reddit、Twitter/X、LinkedIn、Glassdoor、Indeed、Walmart、Zillow、Airbnb、Booking、Crunchbase、eBay、GitHub 等 45 个采集器，走 `POST /builder?platform=1`
+- 🛒 **平台抓取器** — Amazon、YouTube、TikTok、Facebook、Instagram、Reddit、Twitter/X、LinkedIn、Glassdoor、Indeed、Walmart、Zillow、Airbnb、Booking、Crunchbase、eBay、GitHub 等 45 个采集器，先走 `POST /builder?platform=1`，再可查询任务状态并下载结果
 - 📖 **参数全暴露** — 每个工具函数把上游请求参数、类型、是否必填、中文描述都写在签名与 docstring 里；另见 `docs/api_reference.md`
 - 🐍 **零依赖** — 仅用标准库 `urllib`，同步 API
 
@@ -50,17 +50,27 @@ from dataify_sdk import DataifyClient
 from dataify_sdk.tools.amazonproduct import amazon_product_by_asin
 from dataify_sdk.tools.googlesearch import google_search
 
-# token 也可通过环境变量 DATAIFY_TOKEN 提供
+# token 也可通过环境变量 DATAIFY_API_TOKEN 提供（兼容旧版 DATAIFY_TOKEN）
 client = DataifyClient(token="YOUR_TOKEN")
 
-# 采集类：直接提交 Builder 任务
-result = amazon_product_by_asin(asin="B0BZYCJK89", client=client)
+# 采集类：先提交 Builder 任务
+task = amazon_product_by_asin(asin="B0BZYCJK89", client=client)
+task_id = task["data"]["task_id"]
+
+# 再查询任务状态
+status = client.query_scraper_task_status(task_id)
+if status["data"]["status"] == "成功":
+    result = client.download_scraper_task_result(task_id, result_type="json")
 
 # 搜索类：直接打搜索引擎接口
 result = google_search(q="pizza", client=client)
 ```
 
-也可以不传 `client`，使用默认 client（读取 `DATAIFY_TOKEN` 环境变量）：
+也可以不传 `client`，使用默认 client（优先读取 `DATAIFY_API_TOKEN`，兼容 `DATAIFY_TOKEN`）：
+
+```bash
+export DATAIFY_API_TOKEN="..."
+```
 
 ```python
 from dataify_sdk.tools.googlesearch import google_search
@@ -68,6 +78,8 @@ from dataify_sdk.tools.googlesearch import google_search
 result = google_search(q="pizza")
 ```
 
+`client.query_scraper_task_status(...)` 会返回任务状态 JSON，`data.status` 常见值为 `处理中`、`成功`、`失败`。任务成功后可用 `client.download_scraper_task_result(task_id, result_type="json")` 下载最终结果；`result_type` 支持 `json`、`csv`、`xlsx`。
+
 ## API 设计
 
 - **每个 `spider_id` = 一个独立函数**（采集类），例如 `amazon_product_by_asin()`、`amazon_product_by_url()`、`amazon_product_by_keywords()`。

dataify_sdk-1.1.0/PYPI_RELEASE.md

@@ -0,0 +1,136 @@
+# Dataify Python SDK 更新发布步骤
+
+适用于把当前 `dataify-sdk` 新版本发布到 PyPI。
+
+## 1. 更新版本号
+
+修改两个位置，版本号必须一致：
+
+```text
+pyproject.toml
+src/dataify_sdk/__init__.py
+```
+
+例如本次新增公开方法，建议改为：
+
+```text
+1.1.0
+```
+
+## 2. 检查代码状态
+
+```powershell
+git status --short
+```
+
+确认只包含本次要发布的改动。
+
+## 3. 安装开发依赖
+
+```powershell
+python -m pip install -e ".[dev]"
+```
+
+## 4. 运行测试
+
+```powershell
+python -m pytest
+python -m compileall src tests
+```
+
+测试通过后再继续。
+
+## 5. 安装发布工具
+
+```powershell
+python -m pip install --upgrade build twine
+```
+
+## 6. 清理旧构建产物
+
+```powershell
+Remove-Item -LiteralPath .\dist -Recurse -Force -ErrorAction SilentlyContinue
+Remove-Item -LiteralPath .\build -Recurse -Force -ErrorAction SilentlyContinue
+```
+
+## 7. 构建新版本
+
+```powershell
+python -m build
+```
+
+构建后检查 `dist/` 下是否生成：
+
+```text
+*.tar.gz
+*.whl
+```
+
+## 8. 检查发布包
+
+```powershell
+python -m twine check --strict dist/*
+```
+
+必须通过。
+
+## 9. 先发到 TestPyPI
+
+```powershell
+python -m twine upload --repository testpypi dist/*
+```
+
+登录时：
+
+```text
+username: __token__
+password: TestPyPI token
+```
+
+## 10. 从 TestPyPI 安装验证
+
+```powershell
+python -m venv .venv-testpypi-check
+.\.venv-testpypi-check\Scripts\python -m pip install --upgrade pip
+.\.venv-testpypi-check\Scripts\python -m pip install --index-url https://test.pypi.org/simple/ --no-deps dataify-sdk==<版本号>
+.\.venv-testpypi-check\Scripts\python -c "import dataify_sdk; print(dataify_sdk.__version__)"
+```
+
+确认输出版本号正确。
+
+## 11. 发布到正式 PyPI
+
+```powershell
+python -m twine upload dist/*
+```
+
+登录时：
+
+```text
+username: __token__
+password: PyPI token
+```
+
+## 12. 从正式 PyPI 安装验证
+
+```powershell
+python -m venv .venv-pypi-check
+.\.venv-pypi-check\Scripts\python -m pip install --upgrade pip
+.\.venv-pypi-check\Scripts\python -m pip install --no-cache-dir dataify-sdk==<版本号>
+.\.venv-pypi-check\Scripts\python -c "import dataify_sdk; print(dataify_sdk.__version__)"
+```
+
+确认输出版本号正确。
+
+## 13. 打 Git Tag
+
+```powershell
+git tag v<版本号>
+git push origin v<版本号>
+```
+
+## 注意
+
+- PyPI 已发布的同版本不能覆盖上传。
+- token 不要写进代码、README 或提交记录。
+- 如果发布后发现问题，直接修复后发下一个版本。

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/README.md

@@ -6,7 +6,7 @@ Python 客户端库，**直接调用** [Dataify](https://dashboard.dataify.com)
 ## 功能
 
 - 🔍 **搜索引擎** — Google（17 种）、Bing（6 种）、Yandex、DuckDuckGo，走 `POST /request`
-- 🛒 **平台抓取器** — Amazon、YouTube、TikTok、Facebook、Instagram、Reddit、Twitter/X、LinkedIn、Glassdoor、Indeed、Walmart、Zillow、Airbnb、Booking、Crunchbase、eBay、GitHub 等 45 个采集器，走 `POST /builder?platform=1`
+- 🛒 **平台抓取器** — Amazon、YouTube、TikTok、Facebook、Instagram、Reddit、Twitter/X、LinkedIn、Glassdoor、Indeed、Walmart、Zillow、Airbnb、Booking、Crunchbase、eBay、GitHub 等 45 个采集器，先走 `POST /builder?platform=1`，再可查询任务状态并下载结果
 - 📖 **参数全暴露** — 每个工具函数把上游请求参数、类型、是否必填、中文描述都写在签名与 docstring 里；另见 `docs/api_reference.md`
 - 🐍 **零依赖** — 仅用标准库 `urllib`，同步 API
 
@@ -25,23 +25,35 @@ from dataify_sdk import DataifyClient
 from dataify_sdk.tools.amazonproduct import amazon_product_by_asin
 from dataify_sdk.tools.googlesearch import google_search
 
-# token 也可通过环境变量 DATAIFY_TOKEN 提供
-client = DataifyClient(token="YOUR_TOKEN")
-
-# 采集类：直接提交 Builder 任务
-result = amazon_product_by_asin(asin="B0BZYCJK89", client=client)
-
-# 搜索类：直接打搜索引擎接口
-result = google_search(q="pizza", client=client)
-```
-
-也可以不传 `client`，使用默认 client（读取 `DATAIFY_TOKEN` 环境变量）：
-
-```python
-from dataify_sdk.tools.googlesearch import google_search
-
-result = google_search(q="pizza")
-```
+# token 也可通过环境变量 DATAIFY_API_TOKEN 提供（兼容旧版 DATAIFY_TOKEN）
+client = DataifyClient(token="YOUR_TOKEN")
+
+# 采集类：先提交 Builder 任务
+task = amazon_product_by_asin(asin="B0BZYCJK89", client=client)
+task_id = task["data"]["task_id"]
+
+# 再查询任务状态
+status = client.query_scraper_task_status(task_id)
+if status["data"]["status"] == "成功":
+    result = client.download_scraper_task_result(task_id, result_type="json")
+
+# 搜索类：直接打搜索引擎接口
+result = google_search(q="pizza", client=client)
+```
+
+也可以不传 `client`，使用默认 client（优先读取 `DATAIFY_API_TOKEN`，兼容 `DATAIFY_TOKEN`）：
+
+```bash
+export DATAIFY_API_TOKEN="..."
+```
+
+```python
+from dataify_sdk.tools.googlesearch import google_search
+
+result = google_search(q="pizza")
+```
+
+`client.query_scraper_task_status(...)` 会返回任务状态 JSON，`data.status` 常见值为 `处理中`、`成功`、`失败`。任务成功后可用 `client.download_scraper_task_result(task_id, result_type="json")` 下载最终结果；`result_type` 支持 `json`、`csv`、`xlsx`。
 
 ## API 设计
 

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dataify-sdk"
-version = "1.0.0"
+version = "1.1.0"
 description = "Python SDK that calls the Dataify upstream REST API directly (no MCP layer) — web scrapers and search engines."
 readme = "README.md"
 license = {text = "MIT"}

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/scripts/codegen.py

@@ -21,5 +21,8 @@ sys.path.insert(0, str(_ROOT / "src"))
 from dataify_sdk._codegen.generate import main
 
 
+
+
+
 if __name__ == "__main__":
     raise SystemExit(main())

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/src/dataify_sdk/__init__.py

@@ -7,11 +7,18 @@ Typical usage::
     from dataify_sdk.tools.amazonproduct import amazon_product_by_asin
 
     client = DataifyClient(token="YOUR_TOKEN")
-    result = amazon_product_by_asin(asin="B0BZYCJK89", client=client)
-
-or, using the default client (token from ``DATAIFY_TOKEN``)::
-
-    result = amazon_product_by_asin(asin="B0BZYCJK89")
+    task = amazon_product_by_asin(asin="B0BZYCJK89", client=client)
+    task_id = task["data"]["task_id"]
+    status = client.query_scraper_task_status(task_id)
+    if status["data"]["status"] == "成功":
+        result = client.download_scraper_task_result(task_id, result_type="json")
+
+or, using the default client (token from ``DATAIFY_API_TOKEN``, with
+``DATAIFY_TOKEN`` still accepted)::
+
+    task = amazon_product_by_asin(asin="B0BZYCJK89")
+    client = DataifyClient()
+    status = client.query_scraper_task_status(task["data"]["task_id"])
 """
 
 from __future__ import annotations
@@ -24,7 +31,10 @@ from dataify_sdk.errors import (
     DataifyTimeoutError,
 )
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
+
+
+
 
 __all__ = [
     "__version__",

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/src/dataify_sdk/_codegen/generate.py

@@ -434,7 +434,10 @@ def render_scraper_function(
     ]
     for p in sig_params:
         doc.append(_doc_param_line(p, p["upstream"]))
-    doc.append("    client: 可选 DataifyClient 实例;不传则使用默认 client(读取 DATAIFY_TOKEN)。")
+    doc.append(
+        "    client: 可选 DataifyClient 实例;不传则使用默认 client("
+        "优先读取 DATAIFY_API_TOKEN, 兼容 DATAIFY_TOKEN)。"
+    )
     doc.append('    """')
     doc.append("    params_obj = {")
     doc.extend(body_assign)
@@ -492,7 +495,10 @@ def render_serp_function(
     ]
     for p in sig_params:
         doc.append(_doc_param_line(p, p["upstream"]))
-    doc.append("    client: 可选 DataifyClient 实例;不传则使用默认 client(读取 DATAIFY_TOKEN)。")
+    doc.append(
+        "    client: 可选 DataifyClient 实例;不传则使用默认 client("
+        "优先读取 DATAIFY_API_TOKEN, 兼容 DATAIFY_TOKEN)。"
+    )
     doc.append('    """')
     doc.append("    form = {")
     doc.extend(body_assign)

{dataify_sdk-1.0.0 → dataify_sdk-1.1.0}/src/dataify_sdk/client.py

@@ -3,14 +3,19 @@
 This client talks **directly** to the Dataify REST endpoints (the same ones the
 Dataify MCP server proxies), instead of going through the MCP protocol:
 
-* Scraper / platform tools  -> ``POST {base_url}/builder?platform=1``
-  (form fields: ``spider_name``, ``spider_id``, ``spider_parameters``,
-  ``spider_errors``, ``file_name``)
-* Search engines (Google / Bing / Yandex / DuckDuckGo) -> ``POST {base_url}/request``
-  (form fields are the engine-specific parameters plus a fixed ``engine`` value)
-
-Authentication is via a Bearer token, supplied either to the constructor or
-through the ``DATAIFY_TOKEN`` environment variable.
+* Scraper / platform tools  -> ``POST {base_url}/builder?platform=1``
+  (form fields: ``spider_name``, ``spider_id``, ``spider_parameters``,
+  ``spider_errors``, ``file_name``)
+* Scraper task status query -> ``GET {base_url}/task_status``
+  (query params: ``api_key``, ``task_id``)
+* Scraper task result download -> ``GET {base_url}/download``
+  (query params: ``api_key``, ``task_id``, ``type``)
+* Search engines (Google / Bing / Yandex / DuckDuckGo) -> ``POST {base_url}/request``
+  (form fields are the engine-specific parameters plus a fixed ``engine`` value)
+
+Authentication is via a Bearer token, supplied either to the constructor or
+through the ``DATAIFY_API_TOKEN`` environment variable. The legacy
+``DATAIFY_TOKEN`` name is still accepted for backward compatibility.
 """
 
 from __future__ import annotations
@@ -28,23 +33,53 @@ from dataify_sdk.errors import (
     DataifyTimeoutError,
 )
 
-DEFAULT_BASE_URL = "https://scraperapi.dataify.com"
-DEFAULT_TIMEOUT = 120
-ENV_TOKEN = "DATAIFY_TOKEN"
-
-# Endpoints on the upstream.
-_SCRAPER_PATH = "/builder?platform=1"
-_SERP_PATH = "/request"
+DEFAULT_BASE_URL = "https://scraperapi.dataify.com"
+DEFAULT_TIMEOUT = 120
+ENV_TOKEN = "DATAIFY_API_TOKEN"
+LEGACY_ENV_TOKEN = "DATAIFY_TOKEN"
+
+
+def _read_env_token() -> str | None:
+    for env_name in (ENV_TOKEN, LEGACY_ENV_TOKEN):
+        token = os.environ.get(env_name)
+        if token:
+            return token
+    return None
+
+
+def _redact_url(url: str) -> str:
+    try:
+        parsed = urllib.parse.urlsplit(url)
+        query = [
+            (key, "***" if key == "api_key" else value)
+            for key, value in urllib.parse.parse_qsl(
+                parsed.query, keep_blank_values=True
+            )
+        ]
+        return urllib.parse.urlunsplit(
+            parsed._replace(query=urllib.parse.urlencode(query))
+        )
+    except ValueError:
+        return url
+
+
+# Endpoints on the upstream.
+_SCRAPER_PATH = "/builder?platform=1"
+_SCRAPER_TASK_STATUS_PATH = "/task_status"
+_SCRAPER_TASK_RESULT_PATH = "/download"
+_SCRAPER_TASK_RESULT_TYPES = {"json", "csv", "xlsx"}
+_SERP_PATH = "/request"
 
 
 class DataifyClient:
     """Synchronous client for the Dataify upstream REST API.
 
-    Parameters
-    ----------
-    token:
-        Dataify API token. If omitted, the ``DATAIFY_TOKEN`` environment
-        variable is used. A token is required to make any request.
+    Parameters
+    ----------
+    token:
+        Dataify API token. If omitted, the ``DATAIFY_API_TOKEN`` environment
+        variable is used first, with ``DATAIFY_TOKEN`` kept as a legacy
+        fallback. A token is required to make any request.
     base_url:
         Upstream base URL. Fixed to the Dataify production endpoint by default;
         exposed only for testing / private deployments.
@@ -52,56 +87,84 @@ class DataifyClient:
         Per-request timeout in seconds.
     """
 
-    def __init__(
-        self,
-        token: str | None = None,
-        base_url: str = DEFAULT_BASE_URL,
-        timeout: int = DEFAULT_TIMEOUT,
-    ) -> None:
-        self.token = token or os.environ.get(ENV_TOKEN)
-        if not self.token:
-            raise ValueError(
-                "A Dataify token is required: pass token=... or set the "
-                f"{ENV_TOKEN} environment variable."
-            )
-        self.base_url = base_url.rstrip("/")
-        self.timeout = timeout
+    def __init__(
+        self,
+        token: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.token = token or _read_env_token()
+        if not self.token:
+            raise ValueError(
+                "A Dataify token is required: pass token=... or set the "
+                f"{ENV_TOKEN} environment variable (legacy: {LEGACY_ENV_TOKEN})."
+            )
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
 
-    # ------------------------------------------------------------------
-    # Low-level transport
-    # ------------------------------------------------------------------
-    def _post_form(self, path: str, fields: dict[str, str]) -> dict[str, Any]:
-        """POST form-encoded fields and return the parsed JSON response."""
-        url = self.base_url + path
-        # Only send non-empty values (mirrors the Go upstream behaviour).
-        payload = {k: v for k, v in fields.items() if v not in (None, "")}
+    # ------------------------------------------------------------------
+    # Low-level transport
+    # ------------------------------------------------------------------
+    def _read_response_bytes(self, req: urllib.request.Request, url: str) -> bytes:
+        display_url = _redact_url(url)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as exc:  # upstream returned >= 400
+            body = exc.read().decode("utf-8", errors="replace")
+            raise DataifyAPIError(
+                f"Dataify API request failed: {display_url}", exc.code, body
+            ) from exc
+        except urllib.error.URLError as exc:
+            if isinstance(exc.reason, TimeoutError):
+                raise DataifyTimeoutError(
+                    f"Request to {display_url} timed out after {self.timeout}s"
+                ) from exc
+            raise DataifyConnectionError(
+                f"Could not connect to Dataify API at {display_url}: {exc.reason}"
+            ) from exc
+
+    def _read_json_response(
+        self, req: urllib.request.Request, url: str
+    ) -> Any:
+        raw = self._read_response_bytes(req, url).decode(
+            "utf-8", errors="replace"
+        )
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            return {"raw": raw}
+
+    def _post_form(self, path: str, fields: dict[str, str]) -> dict[str, Any]:
+        """POST form-encoded fields and return the parsed JSON response."""
+        url = self.base_url + path
+        # Only send non-empty values (mirrors the Go upstream behaviour).
+        payload = {k: v for k, v in fields.items() if v not in (None, "")}
         data = urllib.parse.urlencode(payload, doseq=False).encode("utf-8")
 
-        req = urllib.request.Request(url, data=data, method="POST")
-        req.add_header("Content-Type", "application/x-www-form-urlencoded")
-        req.add_header("Authorization", f"Bearer {self.token}")
-
-        try:
-            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
-                raw = resp.read().decode("utf-8", errors="replace")
-        except urllib.error.HTTPError as exc:  # upstream returned >= 400
-            body = exc.read().decode("utf-8", errors="replace")
-            raise DataifyAPIError(
-                f"Dataify API request failed: {url}", exc.code, body
-            ) from exc
-        except urllib.error.URLError as exc:
-            if isinstance(exc.reason, TimeoutError):
-                raise DataifyTimeoutError(
-                    f"Request to {url} timed out after {self.timeout}s"
-                ) from exc
-            raise DataifyConnectionError(
-                f"Could not connect to Dataify API at {url}: {exc.reason}"
-            ) from exc
-
-        try:
-            return json.loads(raw)
-        except json.JSONDecodeError:
-            return {"raw": raw}
+        req = urllib.request.Request(url, data=data, method="POST")
+        req.add_header("Content-Type", "application/x-www-form-urlencoded")
+        req.add_header("Authorization", f"Bearer {self.token}")
+        return self._read_json_response(req, url)
+
+    def _get_json(self, path: str, query: dict[str, str]) -> Any:
+        """GET a JSON endpoint with query parameters and return parsed JSON."""
+        url, req = self._build_get_request(path, query)
+        return self._read_json_response(req, url)
+
+    def _get_bytes(self, path: str, query: dict[str, str]) -> bytes:
+        """GET an endpoint with query parameters and return response bytes."""
+        url, req = self._build_get_request(path, query)
+        return self._read_response_bytes(req, url)
+
+    def _build_get_request(
+        self, path: str, query: dict[str, str]
+    ) -> tuple[str, urllib.request.Request]:
+        url = self.base_url + path
+        payload = {k: v for k, v in query.items() if v not in (None, "")}
+        if payload:
+            url = url + "?" + urllib.parse.urlencode(payload, doseq=False)
+        return url, urllib.request.Request(url, method="GET")
 
     # ------------------------------------------------------------------
     # High-level helpers used by the generated tool functions
@@ -146,8 +209,8 @@ class DataifyClient:
             fields["spider_universal"] = spider_universal
         return self._post_form(_SCRAPER_PATH, fields)
 
-    def request_serp(self, engine: str, fields: dict[str, str]) -> dict[str, Any]:
-        """Call a search-engine endpoint.
+    def request_serp(self, engine: str, fields: dict[str, str]) -> dict[str, Any]:
+        """Call a search-engine endpoint.
 
         Parameters
         ----------
@@ -158,20 +221,75 @@ class DataifyClient:
             field names / JSON tags). The ``engine`` field is added
             automatically.
         """
-        form = {"engine": engine}
-        form.update(fields)
-        return self._post_form(_SERP_PATH, form)
+        form = {"engine": engine}
+        form.update(fields)
+        return self._post_form(_SERP_PATH, form)
+
+    def query_scraper_task_status(self, task_id: str) -> dict[str, Any]:
+        """Query a scraper task status by task ID.
+
+        Parameters
+        ----------
+        task_id:
+            Task ID returned by ``request_scraper``.
+        """
+        task_id = task_id.strip()
+        if not task_id:
+            raise ValueError("task_id is required")
+        return self._get_json(
+            _SCRAPER_TASK_STATUS_PATH,
+            {"api_key": self.token, "task_id": task_id},
+        )
+
+    def download_scraper_task_result(
+        self, task_id: str, result_type: str = "json"
+    ) -> Any:
+        """Download a scraper task result.
+
+        Parameters
+        ----------
+        task_id:
+            Task ID returned by ``request_scraper``.
+        result_type:
+            Result format. Supported values are ``"json"``, ``"csv"``, and
+            ``"xlsx"``. JSON results are parsed, CSV results are
+            returned as text, and XLSX results are returned as bytes.
+        """
+        task_id = task_id.strip()
+        if not task_id:
+            raise ValueError("task_id is required")
+
+        result_type = result_type.strip().lower()
+        if result_type not in _SCRAPER_TASK_RESULT_TYPES:
+            raise ValueError(
+                "result_type must be one of: "
+                + ", ".join(sorted(_SCRAPER_TASK_RESULT_TYPES))
+            )
+
+        fields = {
+            "api_key": self.token,
+            "task_id": task_id,
+            "type": result_type,
+        }
+        if result_type == "json":
+            return self._get_json(_SCRAPER_TASK_RESULT_PATH, fields)
+
+        content = self._get_bytes(_SCRAPER_TASK_RESULT_PATH, fields)
+        if result_type == "csv":
+            return content.decode("utf-8", errors="replace")
+        return content
 
 
 _DEFAULT_CLIENT: DataifyClient | None = None
 
 
-def get_default_client() -> DataifyClient:
-    """Return a process-wide default :class:`DataifyClient`.
-
-    Uses ``DATAIFY_TOKEN`` from the environment. Handy for the generated
-    tool functions, which accept an optional ``client`` argument.
-    """
+def get_default_client() -> DataifyClient:
+    """Return a process-wide default :class:`DataifyClient`.
+
+    Uses ``DATAIFY_API_TOKEN`` from the environment, with
+    ``DATAIFY_TOKEN`` kept as a legacy fallback. Handy for the generated
+    tool functions, which accept an optional ``client`` argument.
+    """
     global _DEFAULT_CLIENT
     if _DEFAULT_CLIENT is None:
         _DEFAULT_CLIENT = DataifyClient()