feat(tags): rewrite tag_frequency to read SQLite and export per-category CSVs

Replaces the Parquet-based counter so CSVs come straight from the live
database without an intermediate parquet export step.

scripts/tag_frequency.py

@@ -1,28 +1,132 @@
-import json
+import argparse
+import csv
+import sqlite3
 from collections import Counter
+from pathlib import Path
 
-import pyarrow.parquet as pq
-from tqdm import tqdm
+from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn, TimeElapsedColumn
 
-from _paths import PARQUET_PATH, TAGS_DIR
+from _paths import DANBOORU_DB_PATH, TAGS_DIR
 
+DEFAULT_TAG_FIELDS = (
+    "tag_string_general",
+    "tag_string_artist",
+    "tag_string_character",
+    "tag_string_copyright",
+)
+ALLOWED_TAG_FIELDS = set(DEFAULT_TAG_FIELDS) | {"tag_string", "tag_string_meta"}
+OUTPUT_FILENAMES = {
+    "tag_string_general": "tag_frequency_general.csv",
+    "tag_string_artist": "tag_frequency_artist.csv",
+    "tag_string_character": "tag_frequency_character.csv",
+    "tag_string_copyright": "tag_frequency_copyright.csv",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Count tag frequency from a Danbooru SQLite database and save it as CSV."
+    )
+    parser.add_argument("--database", type=str, default=str(DANBOORU_DB_PATH))
+    parser.add_argument("--tag-field", type=str, default=None, choices=sorted(ALLOWED_TAG_FIELDS))
+    parser.add_argument("--output", type=str, default=None)
+    parser.add_argument("--output-dir", type=str, default=str(TAGS_DIR))
+    parser.add_argument("--start-date", type=str, default=None)
+    parser.add_argument("--batch-size", type=int, default=10_000)
+    args = parser.parse_args()
+    if args.batch_size <= 0:
+        parser.error("--batch-size must be greater than 0")
+    if args.output is not None and args.tag_field is None:
+        parser.error("--output requires --tag-field")
+    return args
+
+
+def build_queries(tag_field: str, start_date: str | None) -> tuple[str, str, tuple[str, ...]]:
+    where_clause = ""
+    params: tuple[str, ...] = ()
+    if start_date is not None:
+        where_clause = " WHERE created_at > ?"
+        params = (start_date,)
+
+    total_query = f"SELECT COUNT(*) FROM posts{where_clause}"
+    data_query = f"SELECT {tag_field} FROM posts{where_clause}"
+    return total_query, data_query, params
+
+
+def count_tags(
+    connection: sqlite3.Connection,
+    tag_field: str,
+    start_date: str | None,
+    batch_size: int,
+) -> Counter[str]:
+    total_query, data_query, params = build_queries(tag_field, start_date)
+    total_count = connection.execute(total_query, params).fetchone()
+    total_rows = int(total_count[0]) if total_count is not None else 0
 
-def main() -> None:
-    TAGS_DIR.mkdir(parents=True, exist_ok=True)
-    table = pq.read_table(str(PARQUET_PATH), columns=["tag_string_general"])
-    tag_columns = ["tag_string_general"]
     counter: Counter[str] = Counter()
+    cursor = connection.execute(data_query, params)
+
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("Counting tags", total=total_rows)
+        while True:
+            rows = cursor.fetchmany(batch_size)
+            if not rows:
+                break
+
+            for (tag_string,) in rows:
+                if not tag_string:
+                    continue
+                counter.update(str(tag_string).split())
 
-    for column in tag_columns:
-        for tags in tqdm(table[column]):
-            if tags is None:
-                continue
-            for tag in tags:
-                counter[tag.as_py()] += 1
+            progress.update(task, advance=len(rows))
+
+    return counter
+
+
+def write_csv(output_file: Path, counter: Counter[str]) -> None:
+    output_path = Path(output_file)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with output_path.open("w", encoding="utf-8", newline="") as csv_file:
+        writer = csv.writer(csv_file)
+        writer.writerow(["tag", "count"])
+        for tag, count in counter.most_common():
+            writer.writerow([tag, count])
+
+
+def build_output_path(output_dir: Path, tag_field: str) -> Path:
+    return output_dir / OUTPUT_FILENAMES.get(tag_field, f"{tag_field}.csv")
+
+
+def iter_tag_fields(tag_field: str | None) -> list[str]:
+    if tag_field is not None:
+        return [tag_field]
+    return list(DEFAULT_TAG_FIELDS)
+
+
+def main() -> None:
+    args = parse_args()
+    output_dir = Path(args.output_dir)
+    tag_fields = iter_tag_fields(args.tag_field)
 
-    output_path = TAGS_DIR / "tag_frequency_general.json"
-    with open(output_path, "w", encoding="utf-8") as outfile:
-        json.dump(counter, outfile)
+    connection = sqlite3.connect(args.database)
+    try:
+        for tag_field in tag_fields:
+            counter = count_tags(
+                connection=connection,
+                tag_field=tag_field,
+                start_date=args.start_date,
+                batch_size=args.batch_size,
+            )
+            output_path = Path(args.output) if args.output is not None else build_output_path(output_dir, tag_field)
+            write_csv(output_file=output_path, counter=counter)
+            print(f"Saved {len(counter)} tags to {output_path}")
+    finally:
+        connection.close()
 
 
 if __name__ == "__main__":