#!/usr/bin/env python3 """HuggingFace Danbooru metadata -> normalized SQLite3 builder.""" from __future__ import annotations import argparse import json import shutil import sqlite3 from pathlib import Path import pyarrow.parquet as pq from huggingface_hub import HfApi, hf_hub_download, snapshot_download DEFAULT_REPO_ID = "trojblue/danbooru2025-metadata" DEFAULT_CACHE_DIR = Path.home() / "Downloads" / "pixiv_spider_hf_probe" POST_COLS = [ "id", "pixiv_id", "source", "rating", "score", "fav_count", "image_width", "image_height", "file_size", "file_ext", "md5", "file_url", "created_at", "updated_at", "uploader_id", "parent_id", ] TAG_COLS = { "tag_string_artist": "artist", "tag_string_character": "character", "tag_string_copyright": "copyright", "tag_string_general": "general", "tag_string_meta": "meta", } REQUIRED_COLS = POST_COLS + list(TAG_COLS.keys()) ALLOWED_RATINGS = {"g", "s", "q", "e"} DROP_POLICY = { "tag_string": "redundant with typed tag_string_* columns", "tag_count*": "derivable from normalized post_tags", "up_score/down_score": "single score column is enough for core ranking", "large_file_url/preview_file_url/has_large": "variant URLs omitted in minimal schema", "approver_id": "moderation detail omitted in minimal schema", "has_*children": "not needed for core queries", "is_pending/is_flagged/is_deleted/is_banned": "status flags omitted in minimal schema", "last_*": "comment/note activity timestamps omitted in minimal schema", "bit_flags": "bitmask omitted in minimal schema", "media_asset_*": "media internals omitted in minimal schema", } PROJECT_ROOT = Path(__file__).resolve().parent PROTECTED_DB = (PROJECT_ROOT / "danbooru.db").resolve() class ConverterError(RuntimeError): pass def parse_tags(value: object) -> list[str]: if value is None: return [] return [x for x in str(value).strip().split() if x] def to_nullable_int(value: object) -> int | None: if value is None: return None if isinstance(value, float): if value != value: return None return int(value) if isinstance(value, int): return value text = str(value).strip() if not text: return None return int(float(text)) def init_db(conn: sqlite3.Connection) -> None: conn.execute("PRAGMA journal_mode=WAL") conn.execute("PRAGMA synchronous=OFF") conn.execute("PRAGMA cache_size=-1048576") conn.execute( """ CREATE TABLE posts ( id INTEGER PRIMARY KEY, pixiv_id INTEGER, source TEXT, rating TEXT, score INTEGER, fav_count INTEGER, image_width INTEGER, image_height INTEGER, file_size INTEGER, file_ext TEXT, md5 TEXT, file_url TEXT, created_at TEXT, updated_at TEXT, uploader_id INTEGER, parent_id INTEGER ) """ ) conn.execute( """ CREATE TABLE tags ( id INTEGER PRIMARY KEY, name TEXT, type TEXT, UNIQUE(name, type) ) """ ) conn.execute( """ CREATE TABLE post_tags ( post_id INTEGER REFERENCES posts(id), tag_id INTEGER REFERENCES tags(id), PRIMARY KEY (post_id, tag_id) ) WITHOUT ROWID """ ) def build_indexes(conn: sqlite3.Connection) -> None: conn.execute("CREATE INDEX idx_posts_pixiv_id ON posts(pixiv_id)") conn.execute("CREATE INDEX idx_posts_source ON posts(source)") conn.execute("CREATE INDEX idx_posts_rating ON posts(rating)") conn.execute("CREATE INDEX idx_posts_score ON posts(score)") conn.execute("CREATE INDEX idx_posts_created_at ON posts(created_at)") conn.execute("CREATE INDEX idx_posts_md5 ON posts(md5)") conn.execute("CREATE INDEX idx_posts_parent_id ON posts(parent_id)") conn.execute("CREATE INDEX idx_tags_name_type ON tags(name, type)") conn.execute("CREATE INDEX idx_tags_type ON tags(type)") conn.execute("CREATE INDEX idx_post_tags_tag_id ON post_tags(tag_id)") conn.commit() def validate_output_path(output_db: Path, overwrite: bool) -> None: output_db = output_db.resolve() if output_db == PROTECTED_DB: raise ConverterError( f"Refusing to write protected DB path: {output_db}" ) if output_db.exists() and not overwrite: raise ConverterError( f"Output DB already exists: {output_db} (pass --overwrite-candidate to replace)" ) def list_repo_parquet_files(repo_id: str) -> tuple[dict, list[str]]: api = HfApi() info = api.dataset_info(repo_id=repo_id, files_metadata=True) files = [] for sibling in info.siblings or []: name = sibling.rfilename if name.endswith(".parquet") and name.startswith("data/"): files.append(name) if not files: raise ConverterError(f"No Parquet files under data/ in dataset {repo_id}") card_data = getattr(info, "card_data", None) or getattr(info, "cardData", None) or {} last_modified = getattr(info, "last_modified", None) or getattr(info, "lastModified", None) meta = { "repo_id": repo_id, "private": bool(getattr(info, "private", False)), "gated": getattr(info, "gated", None), "sha": getattr(info, "sha", None), "last_modified": str(last_modified) if last_modified is not None else None, "card_license": card_data.get("license"), "parquet_file_count": len(files), } return meta, sorted(files) def download_sample_parquet(repo_id: str, parquet_files: list[str], cache_dir: Path, sample_count: int = 2) -> list[Path]: cache_dir.mkdir(parents=True, exist_ok=True) out = [] for name in parquet_files[:sample_count]: local = hf_hub_download( repo_id=repo_id, repo_type="dataset", filename=name, local_dir=str(cache_dir), ) out.append(Path(local)) return out def inspect_parquet_schema(parquet_file: Path) -> list[dict[str, str]]: schema = pq.ParquetFile(parquet_file).schema_arrow return [{"name": field.name, "type": str(field.type)} for field in schema] def validate_required_columns(parquet_file: Path) -> tuple[list[str], list[str]]: schema_names = set(pq.ParquetFile(parquet_file).schema_arrow.names) missing = [c for c in REQUIRED_COLS if c not in schema_names] return sorted(schema_names), missing def inspect_sample_stats(parquet_file: Path, max_rows: int = 5000) -> dict: table = pq.read_table(parquet_file, columns=[ "id", "pixiv_id", "parent_id", "source", "rating", "file_url", "md5", "tag_string_artist", "tag_string_character", "tag_string_copyright", "tag_string_general", "tag_string_meta", ]) if table.num_rows > max_rows: table = table.slice(0, max_rows) data = table.to_pydict() n = len(data["id"]) rating_counts: dict[str, int] = {} invalid_ratings = 0 pixiv_non_null = 0 parent_non_null = 0 source_non_null = 0 file_url_non_null = 0 md5_non_null = 0 tag_non_empty = {k: 0 for k in TAG_COLS} for i in range(n): r = data["rating"][i] if r is not None: rating_counts[str(r)] = rating_counts.get(str(r), 0) + 1 if str(r) not in ALLOWED_RATINGS: invalid_ratings += 1 if data["pixiv_id"][i] is not None: pixiv_non_null += 1 if data["parent_id"][i] is not None: parent_non_null += 1 if data["source"][i]: source_non_null += 1 if data["file_url"][i]: file_url_non_null += 1 if data["md5"][i]: md5_non_null += 1 for col in TAG_COLS: if parse_tags(data[col][i]): tag_non_empty[col] += 1 return { "sample_rows": n, "rating_counts": rating_counts, "invalid_rating_rows": invalid_ratings, "pixiv_non_null": pixiv_non_null, "parent_non_null": parent_non_null, "source_non_null": source_non_null, "file_url_non_null": file_url_non_null, "md5_non_null": md5_non_null, "tag_non_empty_rows": tag_non_empty, } def snapshot_parquet_paths(repo_id: str, cache_dir: Path) -> list[Path]: cache_dir.mkdir(parents=True, exist_ok=True) local_dir = snapshot_download( repo_id=repo_id, repo_type="dataset", local_dir=str(cache_dir), allow_patterns=["data/*.parquet", "README.md", "*.json"], ) data_dir = Path(local_dir) / "data" files = sorted(data_dir.glob("*.parquet")) if not files: raise ConverterError(f"No parquet files found after snapshot_download at {data_dir}") return files def iter_local_parquet(local_parquet_dir: Path) -> list[Path]: files = sorted(local_parquet_dir.glob("train-*.parquet")) if not files: files = sorted(local_parquet_dir.glob("*.parquet")) if not files: raise ConverterError(f"No parquet files found in {local_parquet_dir}") return files def build_db(parquet_files: list[Path], output_db: Path, batch_size: int) -> dict: building_path = output_db.with_suffix(output_db.suffix + ".building") if building_path.exists(): building_path.unlink() conn = sqlite3.connect(building_path) init_db(conn) insert_posts_sql = ( "INSERT OR IGNORE INTO posts VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)" ) insert_tags_sql = "INSERT OR IGNORE INTO tags VALUES (?,?,?)" insert_post_tags_sql = "INSERT OR IGNORE INTO post_tags VALUES (?,?)" tag_cache: dict[tuple[str, str], int] = {} next_tag_id = 1 posts_total = 0 post_tags_total = 0 for idx, file in enumerate(parquet_files, start=1): pf = pq.ParquetFile(file) file_posts = 0 for batch in pf.iter_batches(batch_size=batch_size, columns=REQUIRED_COLS): data = batch.to_pydict() nrows = len(data["id"]) post_rows = [] for i in range(nrows): row = [] for col in POST_COLS: value = data[col][i] if col in {"pixiv_id", "parent_id"}: value = to_nullable_int(value) row.append(value) post_rows.append(tuple(row)) conn.executemany(insert_posts_sql, post_rows) tag_rows = [] post_tag_rows = [] for i in range(nrows): post_id = data["id"][i] for col, ttype in TAG_COLS.items(): for tag_name in parse_tags(data[col][i]): key = (tag_name, ttype) tag_id = tag_cache.get(key) if tag_id is None: tag_id = next_tag_id next_tag_id += 1 tag_cache[key] = tag_id tag_rows.append((tag_id, tag_name, ttype)) post_tag_rows.append((post_id, tag_id)) if tag_rows: conn.executemany(insert_tags_sql, tag_rows) if post_tag_rows: conn.executemany(insert_post_tags_sql, post_tag_rows) conn.commit() posts_total += nrows file_posts += nrows post_tags_total += len(post_tag_rows) print(f"[{idx}/{len(parquet_files)}] {file.name}: {file_posts:,} rows") build_indexes(conn) tag_count = conn.execute("SELECT COUNT(*) FROM tags").fetchone()[0] post_count = conn.execute("SELECT COUNT(*) FROM posts").fetchone()[0] post_tag_count = conn.execute("SELECT COUNT(*) FROM post_tags").fetchone()[0] conn.close() if output_db.exists(): output_db.unlink() building_path.rename(output_db) return { "posts_inserted_rows": posts_total, "post_tags_inserted_rows": post_tags_total, "posts_count": post_count, "tags_count": tag_count, "post_tags_count": post_tag_count, "output_db": str(output_db), } def validate_built_db(output_db: Path) -> dict: conn = sqlite3.connect(output_db) posts = conn.execute("SELECT COUNT(*) FROM posts").fetchone()[0] tags = conn.execute("SELECT COUNT(*) FROM tags").fetchone()[0] post_tags = conn.execute("SELECT COUNT(*) FROM post_tags").fetchone()[0] rating_rows = conn.execute( "SELECT rating, COUNT(*) FROM posts GROUP BY rating ORDER BY rating" ).fetchall() rating_dist = {str(r): c for r, c in rating_rows} pixiv_non_null = conn.execute( "SELECT COUNT(*) FROM posts WHERE pixiv_id IS NOT NULL" ).fetchone()[0] source_non_null = conn.execute( "SELECT COUNT(*) FROM posts WHERE source IS NOT NULL AND source <> ''" ).fetchone()[0] md5_non_null = conn.execute( "SELECT COUNT(*) FROM posts WHERE md5 IS NOT NULL AND md5 <> ''" ).fetchone()[0] parent_non_null = conn.execute( "SELECT COUNT(*) FROM posts WHERE parent_id IS NOT NULL" ).fetchone()[0] broken_pt_post = conn.execute( "SELECT COUNT(*) FROM post_tags pt LEFT JOIN posts p ON p.id = pt.post_id WHERE p.id IS NULL" ).fetchone()[0] broken_pt_tag = conn.execute( "SELECT COUNT(*) FROM post_tags pt LEFT JOIN tags t ON t.id = pt.tag_id WHERE t.id IS NULL" ).fetchone()[0] conn.close() return { "posts": posts, "tags": tags, "post_tags": post_tags, "rating_distribution": rating_dist, "pixiv_non_null": pixiv_non_null, "source_non_null": source_non_null, "md5_non_null": md5_non_null, "parent_non_null": parent_non_null, "broken_post_tags_post_ref": broken_pt_post, "broken_post_tags_tag_ref": broken_pt_tag, } def ensure_disk_space(target_path: Path, required_gb: int = 20) -> None: usage = shutil.disk_usage(target_path.parent) free_gb = usage.free / (1024 ** 3) if free_gb < required_gb: raise ConverterError( f"Insufficient free space in {target_path.parent}: {free_gb:.2f}GB < required {required_gb}GB" ) def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--repo-id", default=DEFAULT_REPO_ID) parser.add_argument("--cache-dir", type=Path, default=DEFAULT_CACHE_DIR) parser.add_argument("--output-db", type=Path, default=PROJECT_ROOT / "danbooru2025_candidate.db") parser.add_argument("--inspect-only", action="store_true") parser.add_argument("--limit-files", type=int, default=0) parser.add_argument("--overwrite-candidate", action="store_true") parser.add_argument("--local-parquet-dir", type=Path) parser.add_argument("--batch-size", type=int, default=50000) parser.add_argument("--json", action="store_true", help="print machine-readable JSON summary") return parser.parse_args() def main() -> None: args = parse_args() meta, repo_parquet_files = list_repo_parquet_files(args.repo_id) sample_files = download_sample_parquet( repo_id=args.repo_id, parquet_files=repo_parquet_files, cache_dir=args.cache_dir, sample_count=2, ) sample_schema = inspect_parquet_schema(sample_files[0]) schema_names, missing = validate_required_columns(sample_files[0]) sample_stats = inspect_sample_stats(sample_files[0]) summary = { "dataset": meta, "sample_file": str(sample_files[0]), "sample_schema_column_count": len(schema_names), "sample_schema": sample_schema, "kept_post_columns": POST_COLS, "normalized_tag_columns": list(TAG_COLS.keys()), "drop_policy": DROP_POLICY, "sample_missing_required_columns": missing, "sample_stats": sample_stats, } if missing: raise ConverterError(f"Missing required columns: {missing}") if args.inspect_only: if args.json: print(json.dumps(summary, ensure_ascii=False, indent=2)) else: print("Inspection summary:") print(json.dumps(summary, ensure_ascii=False, indent=2)) return output_db = args.output_db.resolve() validate_output_path(output_db, overwrite=args.overwrite_candidate) ensure_disk_space(output_db, required_gb=20) if args.local_parquet_dir: parquet_files = iter_local_parquet(args.local_parquet_dir.resolve()) else: parquet_files = snapshot_parquet_paths(args.repo_id, args.cache_dir) if args.limit_files > 0: parquet_files = parquet_files[: args.limit_files] if not parquet_files: raise ConverterError("No parquet files selected for conversion") build_summary = build_db(parquet_files, output_db=output_db, batch_size=args.batch_size) db_summary = validate_built_db(output_db) summary["build"] = build_summary summary["candidate_db_validation"] = db_summary if args.json: print(json.dumps(summary, ensure_ascii=False, indent=2)) else: print("Build summary:") print(json.dumps(summary, ensure_ascii=False, indent=2)) if __name__ == "__main__": try: main() except ConverterError as exc: raise SystemExit(f"error: {exc}")