tinet-data-foundry-cli 0.1.3__tar.gz → 0.1.6__tar.gz

{tinet_data_foundry_cli-0.1.3 → tinet_data_foundry_cli-0.1.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tinet-data-foundry-cli
-Version: 0.1.3
-Summary: Tinet Data Foundry 取数 CLI（catalog / query / schema）
+Version: 0.1.6
+Summary: Tinet Data Foundry 取数 CLI（docs / catalog / query / schema）
 Author: Tinet
 License: MIT
 Project-URL: Homepage, https://data-foundry.tinetcloud.com
@@ -40,9 +40,23 @@ tdf query \
   --filter '{"op":"eq","field":"id","value":"sample"}' \
   --sort '[{"field":"id","direction":"DESC"}]' \
   --page-no 1 \
-  --page-size 10
+  --page-size 10 \
+  --enterprise-range NORMAL \
+  --visitor '{"dingtalkUserId":"钉钉用户ID"}'
 ```
 
+`--enterprise-range` 可省略，服务端默认 `NORMAL`（不含注销用户和集团用户）。`ALL` 两者都包含。应用凭证必须传 `--visitor`，与数据集是否配置行级列无关；JSON 里 `username`、`dingtalkUserId`、`dingtalkUserMobile`、`dingtalkUserEmail` 至少填一个。无行级列时仍须传入，但不加企业过滤。个人凭证不要传。
+
+字符串字段可做模糊匹配，`value` 为非空字符串，`%` 和 `_` 按字面匹配：
+
+| op | 含义 | 示例 |
+| --- | --- | --- |
+| `starts_with` | 右模糊，匹配前缀 | `{"op":"starts_with","field":"name","value":"北京"}` |
+| `ends_with` | 左模糊，匹配后缀 | `{"op":"ends_with","field":"name","value":"公司"}` |
+| `contains` | 左右模糊 | `{"op":"contains","field":"name","value":"科技"}` |
+
+仅按日分区表必须带分区条件。未传分区字段时，服务端按上海时区补当天闭区间，并在响应 `data.partitionWindow` 里返回实际 `field/from/to`。显式 `between` 不超过 30 天，否则 422 `PARTITION_RANGE_INVALID`。按月、按年分区字段不是必填条件。
+
 若 pip 提示 scripts 目录不在 PATH，把该目录加入 PATH，或用 `python3 -m tinet_data_foundry_cli`。
 
 ## Windows（cmd.exe）
@@ -56,7 +70,7 @@ set DF_SK=你的_SecretKey
 
 tdf catalog
 tdf schema --dataset "DATASET_ID"
-tdf query --dataset "DATASET_ID" --fields "id" --filter "{\"op\":\"eq\",\"field\":\"id\",\"value\":\"sample\"}" --sort "[{\"field\":\"id\",\"direction\":\"DESC\"}]" --page-no 1 --page-size 10
+tdf query --dataset "DATASET_ID" --fields "id" --filter "{\"op\":\"eq\",\"field\":\"id\",\"value\":\"sample\"}" --sort "[{\"field\":\"id\",\"direction\":\"DESC\"}]" --page-no 1 --page-size 10 --enterprise-range NORMAL --visitor "{\"dingtalkUserId\":\"钉钉用户ID\"}"
 ```
 
 环境变量只对当前 cmd 窗口有效。JSON 参数用 `\"` 转义，整条命令写在一行。
@@ -70,10 +84,31 @@ tdf catalog --insecure
 
 | 命令 | 接口 |
 | --- | --- |
+| `tdf docs rev` | `GET /docs/credentials/{ak}?format=rev` |
+| `tdf docs pull` | 按 `copy.catalog.policy` 只拉取变化的 `part=public` 或 `part=policy` |
 | `tdf catalog` | `GET /data-api/v1/catalog` |
 | `tdf query` | `POST /data-api/v1/datasets/{id}/query` |
 | `tdf schema` | `GET /data-api/v1/datasets/{id}/schema` |
 
+文档站点默认 `https://data-foundry.tinetcloud.com`，可用 `DF_DOCS_BASE` 覆盖。`tdf docs` 只需要 `DF_AK`。缓存位于 `~/.cache/tinet-data-foundry/docs/<AK 哈希>/`，可用 `DF_DOCS_CACHE` 改根目录。stdout 非终端时 `tdf catalog` 改为 JSON。
+
+### Skill 查询大目录
+
+`tdf docs pull` 把公共目录与授权策略缓存到本机。Skill / Agent 不应直接把大 `public.json` 读进上下文，而是通过以下命令只取需要的精简结果：
+
+```bash
+tdf docs search --query "京东云消费"
+tdf docs describe --dataset "DATASET_ID"
+```
+
+`search` 默认只返回有表权限的数据集；`describe` 只返回该表已授权字段及其脱敏规则。首次使用先执行 `tdf docs pull`。
+
+Agent / Skill 传查询体用文件，避免 shell 转义：
+
+```bash
+tdf query --dataset "DATASET_ID" --body-file query.json
+```
+
 签名：`canonical = METHOD + "\n" + PATH + "\n" + TIMESTAMP + "\n" + NONCE + "\n" + hex(SHA256(body))`，`X-DF-Signature = Base64(HMAC-SHA256(canonical, SK))`。GET 的 body 为空字节。PATH 不含域名、不含 query。
 
 ## 发布到 PyPI

tinet_data_foundry_cli-0.1.6/README.md

@@ -0,0 +1,109 @@
+# tinet-data-foundry-cli
+
+Tinet Data Foundry 取数 CLI。包名 `tinet-data-foundry-cli`，命令 **`tdf`**（避开系统磁盘命令 `df`）。
+
+鉴权只用环境变量，**不要**把 AccessKey / SecretKey 写入本地文件。需要 Python **≥ 3.10**。
+
+macOS / Linux 用 Terminal（bash / zsh）。Windows 用 **cmd.exe** 跑下面示例（不要用 PowerShell 传 JSON：`export` 不可用，引号也会被剥掉）。
+
+## macOS / Linux
+
+```bash
+pip install -U tinet-data-foundry-cli
+
+export DF_ENDPOINT="https://data-foundry-data-api.tinetcloud.com"
+export DF_AK="你的_AccessKey"
+export DF_SK="你的_SecretKey"
+
+tdf catalog
+tdf schema --dataset "DATASET_ID"
+tdf query \
+  --dataset "DATASET_ID" \
+  --fields "id" \
+  --filter '{"op":"eq","field":"id","value":"sample"}' \
+  --sort '[{"field":"id","direction":"DESC"}]' \
+  --page-no 1 \
+  --page-size 10 \
+  --enterprise-range NORMAL \
+  --visitor '{"dingtalkUserId":"钉钉用户ID"}'
+```
+
+`--enterprise-range` 可省略，服务端默认 `NORMAL`（不含注销用户和集团用户）。`ALL` 两者都包含。应用凭证必须传 `--visitor`，与数据集是否配置行级列无关；JSON 里 `username`、`dingtalkUserId`、`dingtalkUserMobile`、`dingtalkUserEmail` 至少填一个。无行级列时仍须传入，但不加企业过滤。个人凭证不要传。
+
+字符串字段可做模糊匹配，`value` 为非空字符串，`%` 和 `_` 按字面匹配：
+
+| op | 含义 | 示例 |
+| --- | --- | --- |
+| `starts_with` | 右模糊，匹配前缀 | `{"op":"starts_with","field":"name","value":"北京"}` |
+| `ends_with` | 左模糊，匹配后缀 | `{"op":"ends_with","field":"name","value":"公司"}` |
+| `contains` | 左右模糊 | `{"op":"contains","field":"name","value":"科技"}` |
+
+仅按日分区表必须带分区条件。未传分区字段时，服务端按上海时区补当天闭区间，并在响应 `data.partitionWindow` 里返回实际 `field/from/to`。显式 `between` 不超过 30 天，否则 422 `PARTITION_RANGE_INVALID`。按月、按年分区字段不是必填条件。
+
+若 pip 提示 scripts 目录不在 PATH，把该目录加入 PATH，或用 `python3 -m tinet_data_foundry_cli`。
+
+## Windows（cmd.exe）
+
+```bat
+pip install -U tinet-data-foundry-cli
+
+set DF_ENDPOINT=https://data-foundry-data-api.tinetcloud.com
+set DF_AK=你的_AccessKey
+set DF_SK=你的_SecretKey
+
+tdf catalog
+tdf schema --dataset "DATASET_ID"
+tdf query --dataset "DATASET_ID" --fields "id" --filter "{\"op\":\"eq\",\"field\":\"id\",\"value\":\"sample\"}" --sort "[{\"field\":\"id\",\"direction\":\"DESC\"}]" --page-no 1 --page-size 10 --enterprise-range NORMAL --visitor "{\"dingtalkUserId\":\"钉钉用户ID\"}"
+```
+
+环境变量只对当前 cmd 窗口有效。JSON 参数用 `\"` 转义，整条命令写在一行。
+
+公司代理 / 自签证书导致 `CERTIFICATE_VERIFY_FAILED` 时：
+
+```bash
+tdf --insecure catalog
+tdf catalog --insecure
+```
+
+| 命令 | 接口 |
+| --- | --- |
+| `tdf docs rev` | `GET /docs/credentials/{ak}?format=rev` |
+| `tdf docs pull` | 按 `copy.catalog.policy` 只拉取变化的 `part=public` 或 `part=policy` |
+| `tdf catalog` | `GET /data-api/v1/catalog` |
+| `tdf query` | `POST /data-api/v1/datasets/{id}/query` |
+| `tdf schema` | `GET /data-api/v1/datasets/{id}/schema` |
+
+文档站点默认 `https://data-foundry.tinetcloud.com`，可用 `DF_DOCS_BASE` 覆盖。`tdf docs` 只需要 `DF_AK`。缓存位于 `~/.cache/tinet-data-foundry/docs/<AK 哈希>/`，可用 `DF_DOCS_CACHE` 改根目录。stdout 非终端时 `tdf catalog` 改为 JSON。
+
+### Skill 查询大目录
+
+`tdf docs pull` 把公共目录与授权策略缓存到本机。Skill / Agent 不应直接把大 `public.json` 读进上下文，而是通过以下命令只取需要的精简结果：
+
+```bash
+tdf docs search --query "京东云消费"
+tdf docs describe --dataset "DATASET_ID"
+```
+
+`search` 默认只返回有表权限的数据集；`describe` 只返回该表已授权字段及其脱敏规则。首次使用先执行 `tdf docs pull`。
+
+Agent / Skill 传查询体用文件，避免 shell 转义：
+
+```bash
+tdf query --dataset "DATASET_ID" --body-file query.json
+```
+
+签名：`canonical = METHOD + "\n" + PATH + "\n" + TIMESTAMP + "\n" + NONCE + "\n" + hex(SHA256(body))`，`X-DF-Signature = Base64(HMAC-SHA256(canonical, SK))`。GET 的 body 为空字节。PATH 不含域名、不含 query。
+
+## 发布到 PyPI
+
+版本号改 `pyproject.toml` 与 `src/tinet_data_foundry_cli/__init__.py`。
+
+```bash
+python -m pip install -U build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+已发布版本号不可覆盖。

{tinet_data_foundry_cli-0.1.3 → tinet_data_foundry_cli-0.1.6}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinet-data-foundry-cli"
-version = "0.1.3"
-description = "Tinet Data Foundry 取数 CLI（catalog / query / schema）"
+version = "0.1.6"
+description = "Tinet Data Foundry 取数 CLI（docs / catalog / query / schema）"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }

tinet_data_foundry_cli-0.1.6/src/tinet_data_foundry_cli/__init__.py

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

{tinet_data_foundry_cli-0.1.3 → tinet_data_foundry_cli-0.1.6}/src/tinet_data_foundry_cli/cli.py

@@ -105,7 +105,10 @@ def cmd_catalog(args: argparse.Namespace) -> int:
         _exit_api(ex)
     except TransportError as ex:
         _exit_transport(ex)
-    if args.dry_run or args.format == "json":
+    fmt = args.format
+    if fmt == "table" and not sys.stdout.isatty():
+        fmt = "json"
+    if args.dry_run or fmt == "json":
         _print_json(parsed)
         return 0
     data = _ok_data(parsed) or {}
@@ -114,23 +117,60 @@ def cmd_catalog(args: argparse.Namespace) -> int:
     return 0
 
 
+def _query_body(args: argparse.Namespace) -> Optional[dict]:
+    if args.body and args.body_file:
+        raise SystemExit("--body 与 --body-file 只能选一个")
+    raw: Optional[str] = None
+    if args.body == "-":
+        raw = sys.stdin.read()
+    elif args.body:
+        raw = args.body
+    elif args.body_file:
+        try:
+            with open(args.body_file, encoding="utf-8") as fh:
+                raw = fh.read()
+        except OSError as ex:
+            raise SystemExit(f"无法读取 --body-file：{ex}") from ex
+    if raw is None:
+        return None
+    for flag, value in (
+        ("--filter", args.filter),
+        ("--fields", args.fields),
+        ("--sort", args.sort),
+        ("--visitor", args.visitor),
+        ("--enterprise-range", args.enterprise_range),
+    ):
+        if value:
+            raise SystemExit(f"使用 --body / --body-file 时不要再传 {flag}")
+    parsed = _parse_json(raw, "--body")
+    if not isinstance(parsed, dict):
+        raise SystemExit("查询 body 必须是 JSON 对象")
+    return parsed
+
+
 def cmd_query(args: argparse.Namespace) -> int:
     base, ak, sk = credentials(args.endpoint)
-    payload: dict[str, Any] = {
-        "pageNo": args.page_no,
-        "pageSize": args.page_size,
-    }
-    if args.fields:
-        payload["fields"] = [p.strip() for p in args.fields.split(",") if p.strip()]
-    filt = _parse_json(args.filter, "--filter")
-    if filt is not None:
-        payload["filter"] = filt
-    sort = _parse_json(args.sort, "--sort")
-    if sort is not None:
-        payload["sort"] = sort
-    visitor = _parse_json(args.visitor, "--visitor")
-    if visitor is not None:
-        payload["visitor"] = visitor
+    body_doc = _query_body(args)
+    if body_doc is not None:
+        payload: dict[str, Any] = body_doc
+    else:
+        payload = {
+            "pageNo": args.page_no,
+            "pageSize": args.page_size,
+        }
+        if args.fields:
+            payload["fields"] = [p.strip() for p in args.fields.split(",") if p.strip()]
+        filt = _parse_json(args.filter, "--filter")
+        if filt is not None:
+            payload["filter"] = filt
+        sort = _parse_json(args.sort, "--sort")
+        if sort is not None:
+            payload["sort"] = sort
+        visitor = _parse_json(args.visitor, "--visitor")
+        if visitor is not None:
+            payload["visitor"] = visitor
+        if args.enterprise_range:
+            payload["enterpriseRange"] = args.enterprise_range
     body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
     path = f"/data-api/v1/datasets/{args.dataset}/query"
     try:
@@ -212,14 +252,40 @@ def build_parser() -> argparse.ArgumentParser:
     q = sub.add_parser("query", help="查询 Dataset")
     _add_insecure(q, overlay=True)
     q.add_argument("--dataset", required=True)
+    q.add_argument("--body", help="完整查询 JSON。- 表示从 stdin 读取。与 --filter 等参数互斥")
+    q.add_argument("--body-file", help="完整查询 JSON 文件。Agent / Skill 用此参数，避免 shell 转义")
     q.add_argument("--fields", help="逗号分隔列名")
-    q.add_argument("--filter", help="filter AST JSON")
+    q.add_argument(
+        "--filter",
+        help=(
+            "filter AST JSON。字符串字段可 starts_with（右模糊）、ends_with（左模糊）、contains（左右模糊）。"
+            "仅按日分区必填：省略分区字段时按上海时区补当天，显式 between 不超过 30 天。"
+            "按月、按年分区字段不是必填条件"
+        ),
+    )
     q.add_argument("--sort", help="sort JSON 数组")
     q.add_argument("--page-no", type=int, default=1)
     q.add_argument("--page-size", type=int, default=10)
-    q.add_argument("--visitor", help="应用凭证 visitor JSON")
+    q.add_argument(
+        "--enterprise-range",
+        choices=["NORMAL", "ALL"],
+        help="检索企业范围。省略时服务端按 NORMAL（不含注销用户和集团用户）；ALL 两者都包含",
+    )
+    q.add_argument(
+        "--visitor",
+        help="应用凭证查询身份 JSON。username、dingtalkUserId、dingtalkUserMobile、dingtalkUserEmail 至少填一个；个人凭证不要传",
+    )
     q.set_defaults(func=cmd_query)
 
+    d = sub.add_parser("docs", help="核对数据集开发文档修订号，并在本地缓存中检索数据集")
+    _add_insecure(d, overlay=True)
+    d.add_argument("action", choices=["rev", "pull", "search", "describe"])
+    d.add_argument("--query", help="search：按名称、描述、表名或业务域检索本地缓存")
+    d.add_argument("--dataset", help="describe：输出指定数据集的已授权字段")
+    d.add_argument("--all", action="store_true", help="search：包含无表权限的数据集")
+    d.add_argument("--docs-base", help="覆盖文档站点。默认 DF_DOCS_BASE 或 https://data-foundry.tinetcloud.com")
+    d.set_defaults(func=cmd_docs)
+
     s = sub.add_parser("schema", help="拉取 Dataset Schema")
     _add_insecure(s, overlay=True)
     s.add_argument("--dataset", required=True)
@@ -227,6 +293,12 @@ def build_parser() -> argparse.ArgumentParser:
     return p
 
 
+def cmd_docs(args: argparse.Namespace) -> int:
+    from tinet_data_foundry_cli.docs import run_docs
+
+    return run_docs(args)
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)

tinet_data_foundry_cli-0.1.6/src/tinet_data_foundry_cli/docs.py

@@ -0,0 +1,290 @@
+"""数据集开发文档：修订号核对与分段缓存。文档接口不签名、不使用 SK。"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import ssl
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+DEFAULT_DOCS_BASE = "https://data-foundry.tinetcloud.com"
+
+
+def access_key() -> str:
+    ak = (os.environ.get("DF_AK") or "").strip()
+    if not ak:
+        raise SystemExit("缺少 DF_AK 环境变量（不要写入本地配置文件）")
+    return ak
+
+
+def docs_base(override: Optional[str] = None) -> str:
+    raw = (override or os.environ.get("DF_DOCS_BASE") or DEFAULT_DOCS_BASE).strip()
+    return raw.rstrip("/")
+
+
+def cache_dir(ak: str) -> Path:
+    digest = hashlib.sha256(ak.encode("utf-8")).hexdigest()[:16]
+    root = (os.environ.get("DF_DOCS_CACHE") or "").strip()
+    base = Path(root) if root else Path.home() / ".cache" / "tinet-data-foundry" / "docs"
+    return base / digest
+
+
+def docs_url(base: str, ak: str, fmt: str, part: Optional[str] = None) -> str:
+    path = "/docs/credentials/" + urllib.parse.quote(ak, safe="")
+    query = {"format": fmt}
+    if part:
+        query["part"] = part
+    return base + path + "?" + urllib.parse.urlencode(query)
+
+
+def run_docs(args: Any) -> int:
+    ak = access_key()
+    base = docs_base(getattr(args, "docs_base", None))
+    folder = cache_dir(ak)
+    if args.action == "search":
+        return _search(folder, str(getattr(args, "query", "") or ""), bool(getattr(args, "all", False)))
+    if args.action == "describe":
+        return _describe(folder, str(getattr(args, "dataset", "") or ""))
+    url = docs_url(base, ak, "rev")
+    if args.dry_run:
+        _print({
+            "dryRun": True,
+            "action": args.action,
+            "url": url,
+            "cacheDir": str(folder),
+        })
+        return 0
+    if args.action == "rev":
+        status, payload = _get_json(url, None, args.timeout, args.insecure)
+        _ensure_ok(payload)
+        _print(payload if status != 304 else _read_json(folder / "rev.json"))
+        return 0
+    return _pull(folder, base, ak, args.timeout, args.insecure)
+
+
+def _cached_docs(folder: Path) -> tuple[Dict[str, Any], Dict[str, Any]]:
+    public = _read_json(folder / "public.json")
+    policy = _read_json(folder / "policy.json")
+    if not public or not policy:
+        raise SystemExit("本地文档缓存不存在，请先运行 tdf docs pull")
+    return public, policy
+
+
+def _search(folder: Path, query: str, include_denied: bool) -> int:
+    public, policy = _cached_docs(folder)
+    needle = query.strip().casefold()
+    if not needle:
+        raise SystemExit("docs search 需要 --query")
+    grants = _index(policy)
+    matches: List[Dict[str, Any]] = []
+    for dataset in public.get("datasets") or []:
+        if not isinstance(dataset, dict):
+            continue
+        grant = grants.get(str(dataset.get("id") or ""), {})
+        if not include_denied and not grant.get("tableGranted"):
+            continue
+        haystack = " ".join(str(dataset.get(key) or "") for key in (
+            "id", "name", "chineseName", "tableComment", "description", "businessDomainName",
+        )).casefold()
+        if needle not in haystack:
+            continue
+        matches.append({
+            "id": dataset.get("id"),
+            "name": dataset.get("name"),
+            "chineseName": dataset.get("chineseName"),
+            "description": dataset.get("description"),
+            "businessDomainName": dataset.get("businessDomainName"),
+            "layer": dataset.get("layer"),
+            "schemaVersion": dataset.get("schemaVersion"),
+            "tableGranted": bool(grant.get("tableGranted")),
+        })
+    _print({"query": query, "datasets": matches})
+    return 0
+
+
+def _describe(folder: Path, dataset_id: str) -> int:
+    public, policy = _cached_docs(folder)
+    if not dataset_id.strip():
+        raise SystemExit("docs describe 需要 --dataset")
+    datasets = _index(public)
+    dataset = datasets.get(dataset_id)
+    if not dataset:
+        raise SystemExit(f"缓存中没有数据集 {dataset_id}；先执行 tdf docs search --query <关键词>")
+    grant = _index(policy).get(dataset_id, {})
+    rules = {
+        str(col.get("name")): col
+        for col in grant.get("columns") or []
+        if isinstance(col, dict) and col.get("granted") and col.get("name")
+    }
+    columns = []
+    for column in dataset.get("columns") or []:
+        if not isinstance(column, dict) or str(column.get("name")) not in rules:
+            continue
+        name = str(column["name"])
+        columns.append({
+            "name": name,
+            "type": column.get("type"),
+            "comment": column.get("comment"),
+            "pk": column.get("pk"),
+            "partition": column.get("partition"),
+            "partitionGrain": column.get("partitionGrain"),
+            "partitionRequired": column.get("partitionRequired"),
+            "outputRule": rules[name].get("outputRule"),
+        })
+    _print({
+        "id": dataset.get("id"),
+        "name": dataset.get("name"),
+        "chineseName": dataset.get("chineseName"),
+        "description": dataset.get("description"),
+        "businessDomainName": dataset.get("businessDomainName"),
+        "schemaVersion": dataset.get("schemaVersion"),
+        "primaryKey": dataset.get("primaryKey"),
+        "partitionFields": dataset.get("partitionFields"),
+        "tableGranted": bool(grant.get("tableGranted")),
+        "columns": columns,
+    })
+    return 0
+
+
+def _pull(folder: Path, base: str, ak: str, timeout: float, insecure: bool) -> int:
+    local = _read_json(folder / "rev.json")
+    local_etag = str(local.get("etag") or "")
+    status, remote = _get_json(docs_url(base, ak, "rev"), local_etag or None, timeout, insecure)
+    if status == 304:
+        _print({
+            "status": "unchanged",
+            "etag": local_etag,
+            "changed": [],
+            "cacheDir": str(folder),
+            "summary": [],
+        })
+        return 0
+    _ensure_ok(remote)
+    etag = str(remote.get("etag") or "")
+    if etag and etag == local_etag and (folder / "public.json").is_file() and (folder / "policy.json").is_file():
+        _print({
+            "status": "unchanged",
+            "etag": etag,
+            "changed": [],
+            "cacheDir": str(folder),
+            "summary": [],
+        })
+        return 0
+    changed: List[str] = []
+    old_public = _read_json(folder / "public.json")
+    old_policy = _read_json(folder / "policy.json")
+    if not local_etag or local.get("copy") != remote.get("copy") or local.get("catalog") != remote.get("catalog"):
+        _, public = _get_json(docs_url(base, ak, "json", "public"), None, timeout, insecure)
+        _ensure_ok(public)
+        _write_json(folder / "public.json", public)
+        changed.append("public")
+    else:
+        public = old_public
+    if not local_etag or local.get("policy") != remote.get("policy"):
+        _, policy = _get_json(docs_url(base, ak, "json", "policy"), None, timeout, insecure)
+        _ensure_ok(policy)
+        _write_json(folder / "policy.json", policy)
+        changed.append("policy")
+    else:
+        policy = old_policy
+    _write_json(folder / "rev.json", {
+        "copy": remote.get("copy"),
+        "catalog": remote.get("catalog"),
+        "policy": remote.get("policy"),
+        "etag": etag,
+    })
+    _print({
+        "status": "updated",
+        "etag": etag,
+        "changed": changed,
+        "cacheDir": str(folder),
+        "summary": summarize(old_public, public, old_policy, policy) if changed else [],
+    })
+    return 0
+
+
+def summarize(old_public: Dict[str, Any], new_public: Dict[str, Any],
+              old_policy: Dict[str, Any], new_policy: Dict[str, Any]) -> List[str]:
+    if not old_public and not old_policy:
+        return ["首次拉取"]
+    lines: List[str] = []
+    old_ds = _index(old_public)
+    new_ds = _index(new_public)
+    for dataset_id in sorted(set(new_ds) - set(old_ds)):
+        lines.append(f"新增数据集 {dataset_id}")
+    for dataset_id in sorted(set(old_ds) - set(new_ds)):
+        lines.append(f"下线数据集 {dataset_id}")
+    for dataset_id in sorted(set(old_ds) & set(new_ds)):
+        if str(old_ds[dataset_id].get("schemaVersion") or "") != str(new_ds[dataset_id].get("schemaVersion") or ""):
+            lines.append(f"schemaVersion 变化 {dataset_id}")
+    old_grants = _index(old_policy)
+    new_grants = _index(new_policy)
+    for dataset_id in sorted(set(old_grants) | set(new_grants)):
+        before = bool(old_grants.get(dataset_id, {}).get("tableGranted"))
+        after = bool(new_grants.get(dataset_id, {}).get("tableGranted"))
+        if before != after:
+            lines.append(f"表权限变化 {dataset_id} {'有' if after else '无'}")
+    return lines[:30]
+
+
+def _index(doc: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+    out: Dict[str, Dict[str, Any]] = {}
+    for row in doc.get("datasets") or []:
+        if isinstance(row, dict) and row.get("id"):
+            out[str(row["id"])] = row
+    return out
+
+
+def _get_json(url: str, etag: Optional[str], timeout: float, insecure: bool):
+    headers = {"Accept": "application/json"}
+    if etag:
+        headers["If-None-Match"] = '"' + etag + '"'
+    req = urllib.request.Request(url, headers=headers, method="GET")
+    ctx = ssl._create_unverified_context() if insecure else None
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
+            raw = resp.read()
+            payload = json.loads(raw.decode("utf-8")) if raw else {}
+            return resp.status, payload
+    except urllib.error.HTTPError as ex:
+        if ex.code == 304:
+            return 304, {}
+        raw = ex.read() if ex.fp else b""
+        try:
+            payload = json.loads(raw.decode("utf-8")) if raw else {"message": str(ex)}
+        except json.JSONDecodeError:
+            payload = {"message": raw.decode("utf-8", errors="replace")}
+        raise SystemExit(f"文档请求失败 HTTP {ex.code}: {payload.get('message', payload)}") from ex
+    except (urllib.error.URLError, ssl.SSLError, TimeoutError, OSError) as ex:
+        raise SystemExit(f"无法连接文档站点：{ex}") from ex
+
+
+def _ensure_ok(payload: Any) -> None:
+    if isinstance(payload, dict) and payload.get("code") not in (None, 0, "0"):
+        raise SystemExit(str(payload.get("message") or payload))
+
+
+def _read_json(path: Path) -> Dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def _print(payload: Any) -> None:
+    json.dump(payload, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")

{tinet_data_foundry_cli-0.1.3 → tinet_data_foundry_cli-0.1.6}/src/tinet_data_foundry_cli.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tinet-data-foundry-cli
-Version: 0.1.3
-Summary: Tinet Data Foundry 取数 CLI（catalog / query / schema）
+Version: 0.1.6
+Summary: Tinet Data Foundry 取数 CLI（docs / catalog / query / schema）
 Author: Tinet
 License: MIT
 Project-URL: Homepage, https://data-foundry.tinetcloud.com
@@ -40,9 +40,23 @@ tdf query \
   --filter '{"op":"eq","field":"id","value":"sample"}' \
   --sort '[{"field":"id","direction":"DESC"}]' \
   --page-no 1 \
-  --page-size 10
+  --page-size 10 \
+  --enterprise-range NORMAL \
+  --visitor '{"dingtalkUserId":"钉钉用户ID"}'
 ```
 
+`--enterprise-range` 可省略，服务端默认 `NORMAL`（不含注销用户和集团用户）。`ALL` 两者都包含。应用凭证必须传 `--visitor`，与数据集是否配置行级列无关；JSON 里 `username`、`dingtalkUserId`、`dingtalkUserMobile`、`dingtalkUserEmail` 至少填一个。无行级列时仍须传入，但不加企业过滤。个人凭证不要传。
+
+字符串字段可做模糊匹配，`value` 为非空字符串，`%` 和 `_` 按字面匹配：
+
+| op | 含义 | 示例 |
+| --- | --- | --- |
+| `starts_with` | 右模糊，匹配前缀 | `{"op":"starts_with","field":"name","value":"北京"}` |
+| `ends_with` | 左模糊，匹配后缀 | `{"op":"ends_with","field":"name","value":"公司"}` |
+| `contains` | 左右模糊 | `{"op":"contains","field":"name","value":"科技"}` |
+
+仅按日分区表必须带分区条件。未传分区字段时，服务端按上海时区补当天闭区间，并在响应 `data.partitionWindow` 里返回实际 `field/from/to`。显式 `between` 不超过 30 天，否则 422 `PARTITION_RANGE_INVALID`。按月、按年分区字段不是必填条件。
+
 若 pip 提示 scripts 目录不在 PATH，把该目录加入 PATH，或用 `python3 -m tinet_data_foundry_cli`。
 
 ## Windows（cmd.exe）
@@ -56,7 +70,7 @@ set DF_SK=你的_SecretKey
 
 tdf catalog
 tdf schema --dataset "DATASET_ID"
-tdf query --dataset "DATASET_ID" --fields "id" --filter "{\"op\":\"eq\",\"field\":\"id\",\"value\":\"sample\"}" --sort "[{\"field\":\"id\",\"direction\":\"DESC\"}]" --page-no 1 --page-size 10
+tdf query --dataset "DATASET_ID" --fields "id" --filter "{\"op\":\"eq\",\"field\":\"id\",\"value\":\"sample\"}" --sort "[{\"field\":\"id\",\"direction\":\"DESC\"}]" --page-no 1 --page-size 10 --enterprise-range NORMAL --visitor "{\"dingtalkUserId\":\"钉钉用户ID\"}"
 ```
 
 环境变量只对当前 cmd 窗口有效。JSON 参数用 `\"` 转义，整条命令写在一行。
@@ -70,10 +84,31 @@ tdf catalog --insecure
 
 | 命令 | 接口 |
 | --- | --- |
+| `tdf docs rev` | `GET /docs/credentials/{ak}?format=rev` |
+| `tdf docs pull` | 按 `copy.catalog.policy` 只拉取变化的 `part=public` 或 `part=policy` |
 | `tdf catalog` | `GET /data-api/v1/catalog` |
 | `tdf query` | `POST /data-api/v1/datasets/{id}/query` |
 | `tdf schema` | `GET /data-api/v1/datasets/{id}/schema` |
 
+文档站点默认 `https://data-foundry.tinetcloud.com`，可用 `DF_DOCS_BASE` 覆盖。`tdf docs` 只需要 `DF_AK`。缓存位于 `~/.cache/tinet-data-foundry/docs/<AK 哈希>/`，可用 `DF_DOCS_CACHE` 改根目录。stdout 非终端时 `tdf catalog` 改为 JSON。
+
+### Skill 查询大目录
+
+`tdf docs pull` 把公共目录与授权策略缓存到本机。Skill / Agent 不应直接把大 `public.json` 读进上下文，而是通过以下命令只取需要的精简结果：
+
+```bash
+tdf docs search --query "京东云消费"
+tdf docs describe --dataset "DATASET_ID"
+```
+
+`search` 默认只返回有表权限的数据集；`describe` 只返回该表已授权字段及其脱敏规则。首次使用先执行 `tdf docs pull`。
+
+Agent / Skill 传查询体用文件，避免 shell 转义：
+
+```bash
+tdf query --dataset "DATASET_ID" --body-file query.json
+```
+
 签名：`canonical = METHOD + "\n" + PATH + "\n" + TIMESTAMP + "\n" + NONCE + "\n" + hex(SHA256(body))`，`X-DF-Signature = Base64(HMAC-SHA256(canonical, SK))`。GET 的 body 为空字节。PATH 不含域名、不含 query。
 
 ## 发布到 PyPI

{tinet_data_foundry_cli-0.1.3 → tinet_data_foundry_cli-0.1.6}/src/tinet_data_foundry_cli.egg-info/SOURCES.txt

@@ -5,10 +5,12 @@ src/tinet_data_foundry_cli/__main__.py
 src/tinet_data_foundry_cli/auth.py
 src/tinet_data_foundry_cli/cli.py
 src/tinet_data_foundry_cli/client.py
+src/tinet_data_foundry_cli/docs.py
 src/tinet_data_foundry_cli.egg-info/PKG-INFO
 src/tinet_data_foundry_cli.egg-info/SOURCES.txt
 src/tinet_data_foundry_cli.egg-info/dependency_links.txt
 src/tinet_data_foundry_cli.egg-info/entry_points.txt
 src/tinet_data_foundry_cli.egg-info/top_level.txt
 tests/test_cli.py
+tests/test_docs.py
 tests/test_sign.py

tinet_data_foundry_cli-0.1.6/tests/test_cli.py

@@ -0,0 +1,98 @@
+import json
+import unittest
+from io import StringIO
+from unittest.mock import patch
+
+from tinet_data_foundry_cli.cli import build_parser, main
+
+
+class CliParserTest(unittest.TestCase):
+    def test_query_filter_help_mentions_string_match(self):
+        parser = build_parser()
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            with self.assertRaises(SystemExit) as ctx:
+                parser.parse_args(["query", "--help"])
+        self.assertEqual(ctx.exception.code, 0)
+        help_text = out.getvalue()
+        self.assertIn("starts_with", help_text)
+        self.assertIn("ends_with", help_text)
+        self.assertIn("contains", help_text)
+        self.assertIn("仅按日分区必填", help_text)
+        self.assertIn("30", help_text)
+        self.assertIn("当天", help_text)
+        self.assertIn("按月、按年分区字段不是必填条件", help_text)
+        self.assertNotIn("按月补当月", help_text)
+
+    def test_subcommands(self):
+        parser = build_parser()
+        catalog = parser.parse_args(["catalog", "--format", "json"])
+        self.assertEqual(catalog.cmd, "catalog")
+        query = parser.parse_args(["query", "--dataset", "ds_1", "--page-no", "1", "--page-size", "10"])
+        self.assertEqual(query.cmd, "query")
+        catalog_k = parser.parse_args(["catalog", "--insecure"])
+        self.assertTrue(catalog_k.insecure)
+        catalog_before = parser.parse_args(["--insecure", "catalog"])
+        self.assertTrue(catalog_before.insecure)
+
+    def test_query_enterprise_range_and_visitor(self):
+        parser = build_parser()
+        query = parser.parse_args([
+            "query", "--dataset", "ds_1", "--enterprise-range", "ALL",
+            "--visitor", "{\"dingtalkUserId\":\"dt-1\"}",
+        ])
+        self.assertEqual(query.enterprise_range, "ALL")
+        env = {"DF_ENDPOINT": "https://example.test", "DF_AK": "ak", "DF_SK": "sk" * 8}
+        with patch.dict("os.environ", env, clear=False), patch("sys.stdout", new_callable=StringIO) as out:
+            code = main([
+                "--dry-run", "query", "--dataset", "ds_1", "--enterprise-range", "ALL",
+                "--visitor", "{\"dingtalkUserId\":\"dt-1\"}",
+            ])
+        self.assertEqual(code, 0)
+        body = json.loads(json.loads(out.getvalue())["body"])
+        self.assertEqual(body["enterpriseRange"], "ALL")
+        self.assertEqual(body["visitor"]["dingtalkUserId"], "dt-1")
+        self.assertNotIn("enterpriseRange", json.loads(json.loads(
+            self._dry_query(["--dry-run", "query", "--dataset", "ds_1"])
+        )["body"]))
+
+    def _dry_query(self, argv):
+        env = {"DF_ENDPOINT": "https://example.test", "DF_AK": "ak", "DF_SK": "sk" * 8}
+        with patch.dict("os.environ", env, clear=False), patch("sys.stdout", new_callable=StringIO) as out:
+            self.assertEqual(main(argv), 0)
+            return out.getvalue()
+
+    def test_dry_run_catalog_does_not_need_network(self):
+        with patch.dict("os.environ", {"DF_AK": "ak", "DF_SK": "sk" * 8}, clear=False):
+            code = main(["--dry-run", "catalog"])
+        self.assertEqual(code, 0)
+
+    def test_query_body_file_is_the_post_body(self):
+        import tempfile
+        payload = {"fields": ["id"], "pageNo": 1, "pageSize": 5, "filter": {"op": "eq", "field": "id", "value": "a"}}
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False, encoding="utf-8") as fh:
+            json.dump(payload, fh)
+            path = fh.name
+        env = {"DF_ENDPOINT": "https://example.test", "DF_AK": "ak", "DF_SK": "sk" * 8}
+        with patch.dict("os.environ", env, clear=False), patch("sys.stdout", new_callable=StringIO) as out:
+            code = main(["--dry-run", "query", "--dataset", "ds_1", "--body-file", path])
+        self.assertEqual(code, 0)
+        body = json.loads(json.loads(out.getvalue())["body"])
+        self.assertEqual(body["fields"], ["id"])
+        self.assertEqual(body["pageSize"], 5)
+        with patch.dict("os.environ", env, clear=False):
+            with self.assertRaises(SystemExit):
+                main(["--dry-run", "query", "--dataset", "ds_1", "--body-file", path, "--filter", "{}"])
+
+    def test_docs_pull_dry_run_does_not_need_network(self):
+        env = {"DF_AK": "DFAK_example"}
+        with patch.dict("os.environ", env, clear=False), patch("sys.stdout", new_callable=StringIO) as out:
+            code = main(["--dry-run", "docs", "pull"])
+        self.assertEqual(code, 0)
+        printed = json.loads(out.getvalue())
+        self.assertTrue(printed["dryRun"])
+        self.assertIn("/docs/credentials/DFAK_example?format=rev", printed["url"])
+        self.assertNotIn("sk", printed)
+
+
+if __name__ == "__main__":
+    unittest.main()

tinet_data_foundry_cli-0.1.6/tests/test_docs.py

@@ -0,0 +1,76 @@
+import json
+import tempfile
+import unittest
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+from tinet_data_foundry_cli.docs import _describe, _search, summarize
+
+
+class DocsSummaryTest(unittest.TestCase):
+    def test_search_and_describe_only_print_authorized_dataset_content(self):
+        with tempfile.TemporaryDirectory() as tmp, patch("sys.stdout", new_callable=StringIO) as out:
+            folder = Path(tmp)
+            (folder / "public.json").write_text(json.dumps({"datasets": [{
+                "id": "ds_bill", "name": "monthly_bill", "chineseName": "月账单",
+                "description": "京东云消费", "columns": [
+                    {"name": "amount", "type": "decimal", "comment": "金额"},
+                    {"name": "secret", "type": "text", "comment": "无权限"},
+                ],
+            }]}), encoding="utf-8")
+            (folder / "policy.json").write_text(json.dumps({"datasets": [{
+                "id": "ds_bill", "tableGranted": True,
+                "columns": [{"name": "amount", "granted": True, "outputRule": "PLAIN"}],
+            }]}), encoding="utf-8")
+            self.assertEqual(_search(folder, "京东云", False), 0)
+            search = json.loads(out.getvalue())
+            self.assertEqual(search["datasets"][0]["id"], "ds_bill")
+            out.seek(0)
+            out.truncate(0)
+            self.assertEqual(_describe(folder, "ds_bill"), 0)
+            described = json.loads(out.getvalue())
+            self.assertEqual([col["name"] for col in described["columns"]], ["amount"])
+
+    def test_summarize_catalog_and_policy(self):
+        old_public = {"datasets": [{"id": "a", "schemaVersion": "1"}, {"id": "b", "schemaVersion": "1"}]}
+        new_public = {"datasets": [{"id": "b", "schemaVersion": "2"}, {"id": "c", "schemaVersion": "1"}]}
+        old_policy = {"datasets": [{"id": "a", "tableGranted": True}, {"id": "b", "tableGranted": False}]}
+        new_policy = {"datasets": [{"id": "b", "tableGranted": True}, {"id": "c", "tableGranted": False}]}
+        lines = summarize(old_public, new_public, old_policy, new_policy)
+        self.assertIn("新增数据集 c", lines)
+        self.assertIn("下线数据集 a", lines)
+        self.assertIn("schemaVersion 变化 b", lines)
+        self.assertIn("表权限变化 b 有", lines)
+
+    def test_pull_fetches_only_policy_when_catalog_unchanged(self):
+        from tinet_data_foundry_cli import docs as docs_mod
+
+        rev = {"copy": "c", "catalog": "k", "policy": "p2", "etag": "c.k.p2"}
+        calls = []
+
+        def fake_get(url, etag, timeout, insecure):
+            calls.append(url)
+            if "format=rev" in url:
+                return 200, rev
+            if "part=policy" in url:
+                return 200, {"credentialType": "PERSONAL", "datasets": [{"id": "a", "tableGranted": True, "columns": []}]}
+            raise AssertionError(url)
+
+        with tempfile.TemporaryDirectory() as tmp:
+            folder = Path(tmp)
+            (folder / "rev.json").write_text(json.dumps({
+                "copy": "c", "catalog": "k", "policy": "p1", "etag": "c.k.p1",
+            }), encoding="utf-8")
+            (folder / "public.json").write_text(json.dumps({"datasets": [{"id": "a"}]}), encoding="utf-8")
+            with patch.object(docs_mod, "_get_json", fake_get):
+                code = docs_mod._pull(folder, "https://docs.example", "DFAK_x", 5, False)
+            self.assertEqual(code, 0)
+            self.assertTrue(any("part=policy" in url for url in calls))
+            self.assertFalse(any("part=public" in url for url in calls))
+            saved = json.loads((folder / "rev.json").read_text(encoding="utf-8"))
+            self.assertEqual(saved["policy"], "p2")
+
+
+if __name__ == "__main__":
+    unittest.main()

tinet_data_foundry_cli-0.1.3/README.md

@@ -1,74 +0,0 @@
-# tinet-data-foundry-cli
-
-Tinet Data Foundry 取数 CLI。包名 `tinet-data-foundry-cli`，命令 **`tdf`**（避开系统磁盘命令 `df`）。
-
-鉴权只用环境变量，**不要**把 AccessKey / SecretKey 写入本地文件。需要 Python **≥ 3.10**。
-
-macOS / Linux 用 Terminal（bash / zsh）。Windows 用 **cmd.exe** 跑下面示例（不要用 PowerShell 传 JSON：`export` 不可用，引号也会被剥掉）。
-
-## macOS / Linux
-
-```bash
-pip install -U tinet-data-foundry-cli
-
-export DF_ENDPOINT="https://data-foundry-data-api.tinetcloud.com"
-export DF_AK="你的_AccessKey"
-export DF_SK="你的_SecretKey"
-
-tdf catalog
-tdf schema --dataset "DATASET_ID"
-tdf query \
-  --dataset "DATASET_ID" \
-  --fields "id" \
-  --filter '{"op":"eq","field":"id","value":"sample"}' \
-  --sort '[{"field":"id","direction":"DESC"}]' \
-  --page-no 1 \
-  --page-size 10
-```
-
-若 pip 提示 scripts 目录不在 PATH，把该目录加入 PATH，或用 `python3 -m tinet_data_foundry_cli`。
-
-## Windows（cmd.exe）
-
-```bat
-pip install -U tinet-data-foundry-cli
-
-set DF_ENDPOINT=https://data-foundry-data-api.tinetcloud.com
-set DF_AK=你的_AccessKey
-set DF_SK=你的_SecretKey
-
-tdf catalog
-tdf schema --dataset "DATASET_ID"
-tdf query --dataset "DATASET_ID" --fields "id" --filter "{\"op\":\"eq\",\"field\":\"id\",\"value\":\"sample\"}" --sort "[{\"field\":\"id\",\"direction\":\"DESC\"}]" --page-no 1 --page-size 10
-```
-
-环境变量只对当前 cmd 窗口有效。JSON 参数用 `\"` 转义，整条命令写在一行。
-
-公司代理 / 自签证书导致 `CERTIFICATE_VERIFY_FAILED` 时：
-
-```bash
-tdf --insecure catalog
-tdf catalog --insecure
-```
-
-| 命令 | 接口 |
-| --- | --- |
-| `tdf catalog` | `GET /data-api/v1/catalog` |
-| `tdf query` | `POST /data-api/v1/datasets/{id}/query` |
-| `tdf schema` | `GET /data-api/v1/datasets/{id}/schema` |
-
-签名：`canonical = METHOD + "\n" + PATH + "\n" + TIMESTAMP + "\n" + NONCE + "\n" + hex(SHA256(body))`，`X-DF-Signature = Base64(HMAC-SHA256(canonical, SK))`。GET 的 body 为空字节。PATH 不含域名、不含 query。
-
-## 发布到 PyPI
-
-版本号改 `pyproject.toml` 与 `src/tinet_data_foundry_cli/__init__.py`。
-
-```bash
-python -m pip install -U build twine
-python -m build
-python -m twine check dist/*
-python -m twine upload --repository testpypi dist/*
-python -m twine upload dist/*
-```
-
-已发布版本号不可覆盖。

tinet_data_foundry_cli-0.1.3/src/tinet_data_foundry_cli/__init__.py

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

tinet_data_foundry_cli-0.1.3/tests/test_cli.py

@@ -1,26 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from tinet_data_foundry_cli.cli import build_parser, main
-
-
-class CliParserTest(unittest.TestCase):
-    def test_subcommands(self):
-        parser = build_parser()
-        catalog = parser.parse_args(["catalog", "--format", "json"])
-        self.assertEqual(catalog.cmd, "catalog")
-        query = parser.parse_args(["query", "--dataset", "ds_1", "--page-no", "1", "--page-size", "10"])
-        self.assertEqual(query.cmd, "query")
-        catalog_k = parser.parse_args(["catalog", "--insecure"])
-        self.assertTrue(catalog_k.insecure)
-        catalog_before = parser.parse_args(["--insecure", "catalog"])
-        self.assertTrue(catalog_before.insecure)
-
-    def test_dry_run_catalog_does_not_need_network(self):
-        with patch.dict("os.environ", {"DF_AK": "ak", "DF_SK": "sk" * 8}, clear=False):
-            code = main(["--dry-run", "catalog"])
-        self.assertEqual(code, 0)
-
-
-if __name__ == "__main__":
-    unittest.main()