feat(scripts): add fetch scripts

.gitignore

@@ -0,0 +1,2 @@
+venv
+__pycache__

README.md

@@ -2,4 +2,12 @@
 license: mit
 ---
 
-combined <https://huggingface.co/datasets/nyanko7/danbooru2023> and <https://huggingface.co/datasets/deepghs/danbooru_newest>.
+Metadata of all posts from Danbooru.
+
+I did not include the media_asset field because it is largely redundant with other fields.
+
+Compared to the metadata available at <https://huggingface.co/datasets/nyanko7/danbooru2023>, the data here was collected at a later time. This means that many fields may differ, such as score. Some tags and author aliases are also more complete.
+
+Here, we have attached both the script for updating metadata and the script for downloading images based on the metadata database.
+
+On my PC, We can download all metadata in about 1 hours.

danbooru_metadata.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f32d0ffc3fafb17e43d9efaefb44c280610d2993dcd75881607ad919283c9d1b
-size 19277389824
+oid sha256:57f0d40383d45b546f8546c2fad51c6e398c472e92089d2137f4519e76533295
+size 11417427968

db.py

@@ -0,0 +1,95 @@
+import sqlite3
+from sqlalchemy import Column, Float, Index, Integer, MetaData, Table, Text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import create_engine
+
+Base = declarative_base()
+metadata = MetaData()
+
+t_posts = Table(
+    "posts",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("filename", Text),
+    Column("mimetype", Text),
+    Column("extension", Text),
+    Column("width", Integer),
+    Column("height", Integer),
+    Column("rating", Text),
+    Column("file_url", Text),
+    Column("created_at", Text),
+    Column("uploader_id", Integer),
+    Column("score", Integer),
+    Column("source", Text),
+    Column("md5", Text),
+    Column("last_comment_bumped_at", Text),
+    Column("image_width", Integer),
+    Column("image_height", Integer),
+    Column("tag_string", Text),
+    Column("fav_count", Integer),
+    Column("file_ext", Text),
+    Column("last_noted_at", Text),
+    Column("parent_id", Float),
+    Column("has_children", Integer),
+    Column("approver_id", Float),
+    Column("tag_count_general", Integer),
+    Column("tag_count_artist", Integer),
+    Column("tag_count_character", Integer),
+    Column("tag_count_copyright", Integer),
+    Column("file_size", Integer),
+    Column("up_score", Integer),
+    Column("down_score", Integer),
+    Column("is_pending", Integer),
+    Column("is_flagged", Integer),
+    Column("is_deleted", Integer),
+    Column("tag_count", Integer),
+    Column("updated_at", Text),
+    Column("is_banned", Integer),
+    Column("pixiv_id", Float),
+    Column("last_commented_at", Text),
+    Column("has_active_children", Integer),
+    Column("bit_flags", Integer),
+    Column("tag_count_meta", Integer),
+    Column("has_large", Integer),
+    Column("has_visible_children", Integer),
+    Column("tag_string_general", Text),
+    Column("tag_string_character", Text),
+    Column("tag_string_copyright", Text),
+    Column("tag_string_artist", Text),
+    Column("tag_string_meta", Text),
+    Column("large_file_url", Text),
+    Column("preview_file_url", Text),
+    Index("posts_index_file_url", "file_url"),
+    Index("posts_index_tag_count_artist", "tag_count_artist"),
+    Index("posts_index_tag_count_character", "tag_count_character"),
+    Index("posts_index_tag_count_copyright", "tag_count_copyright"),
+    Index("posts_index_tag_count_general", "tag_count_general"),
+    Index("posts_index_tag_count_meta", "tag_count_meta"),
+    Index("posts_index_tag_string", "tag_string"),
+    Index("posts_index_tag_string_artist", "tag_string_artist"),
+    Index("posts_index_tag_string_character", "tag_string_character"),
+    Index("posts_index_tag_string_copyright", "tag_string_copyright"),
+    Index("posts_index_tag_string_general", "tag_string_general"),
+    Index("posts_index_tag_string_meta", "tag_string_meta"),
+    Index("posts_index_rating", "rating"),
+    Index("posts_index_score", "score"),
+)
+
+
+def connect_db(db_name):
+    return sqlite3.connect(db_name)
+
+
+def get_engine(db_name):
+
+    return create_engine(f"sqlite:///{db_name}")
+
+
+def get_session(engine):
+    Session = sessionmaker(bind=engine)
+    return Session()
+
+
+if __name__ == "__main__":
+    print("Database has been created.")

download_images.py

@@ -0,0 +1,107 @@
+import sqlite3
+import os
+import threading
+import queue
+import requests
+
+# Database and output directory setup
+DB_PATH = "danbooru_metadata.db"
+OUT_DIR = "./image"
+
+# Number of download threads
+NUM_THREADS = 16
+
+# Task queue to hold file URLs and IDs
+task_queue = queue.Queue()
+
+IMAGE_EXTENSIONS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "bmp",
+    "PNG",
+    "JPG",
+    "JPEG",
+    "WEBP",
+    "BMP",
+]
+
+
+def fetch_posts_to_queue():
+    """Fetch posts from SQLite database and put them in the task queue."""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    print("Fetching posts")
+    cursor.execute("SELECT id, file_url, file_ext FROM posts")
+    while True:
+        post = cursor.fetchone()
+        if post is None:
+            break
+        (post_id, file_url, file_ext) = post
+
+        # Check if the file already exists
+        if os.path.exists(os.path.join(OUT_DIR, f"{post_id}.{file_ext}")):
+            continue
+
+        # Check if the file_ext is an image
+        if file_url is not None and file_ext in IMAGE_EXTENSIONS:
+            task_queue.put((post_id, file_url))
+    print("All posts fetched")
+    conn.close()
+
+
+def download_image(post_id, url):
+    """Download image from the given URL and save it to the out_dir."""
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+
+        # Calculate directory based on post_id and create it if necessary
+        directory = os.path.join(OUT_DIR, f"{post_id % 1000:04d}")
+        os.makedirs(directory, exist_ok=True)
+        ext = url.split(".")[-1]
+        # Determine file path and save the image
+        file_path = os.path.join(directory, f"{post_id}.{ext}")
+        with open(file_path, "wb") as f:
+            for chunk in response.iter_content(1024):
+                f.write(chunk)
+        # print(f"Downloaded {file_path}")
+    except requests.RequestException as e:
+        print(f"Failed to download {url}: {e}")
+
+
+def worker():
+    """Worker thread function to download images."""
+    while True:
+        try:
+            post_id, url = task_queue.get()
+        except queue.Empty:
+            break
+        download_image(post_id, url)
+        task_queue.task_done()
+
+
+if __name__ == "__main__":
+    # Populate the task queue
+
+    # Create and start worker threads
+    threads = []
+    for _ in range(NUM_THREADS):
+        thread = threading.Thread(target=worker)
+        thread.start()
+        threads.append(thread)
+    # Wait for all threads to finish
+    try:
+        fetch_posts_to_queue()
+
+        # Ensure all tasks are done
+        task_queue.join()
+
+        for thread in threads:
+            thread.join()
+
+        print("All downloads completed.")
+    except KeyboardInterrupt:
+        print("Download interrupted.")
+        os._exit(1)

requirements.txt

@@ -0,0 +1,3 @@
+requests
+rich
+sqlalchemy

update_danbooru.py

@@ -0,0 +1,176 @@
+import queue
+import threading
+import time
+from time import sleep
+
+import requests
+from rich.progress import (
+    BarColumn,
+    Progress,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+from sqlalchemy import text
+import argparse
+
+from db import get_engine, t_posts
+
+url_queue = queue.Queue(maxsize=64)
+data_queue = queue.Queue()
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--start_id", type=int, default=1)
+parser.add_argument("--api_key", type=str)
+parser.add_argument("--login", type=str)
+parser.add_argument("--workers", type=int, default=16)
+args = parser.parse_args()
+
+API_KEY = args.api_key
+LOGIN = args.login
+
+
+start_id = args.start_id
+
+base_api_url = (
+    "https://danbooru.donmai.us/posts.json?page=a{}&limit=200&api_key={}&login={}"
+)
+latest_id_url = "https://danbooru.donmai.us/posts.json?api_key={}&login={}"
+
+latest_id = 1  # latset id
+
+
+# get latest ID
+def fetch_latest_id(max_retries=5, backoff_factor=1):
+    global latest_id
+    attempt = 0
+
+    while attempt < max_retries:
+        try:
+            response = requests.get(latest_id_url.format(API_KEY, LOGIN))
+            if response.status_code == 200:
+                data = response.json()
+                if data and "id" in data[0]:
+                    latest_id = data[0]["id"]
+                    return  # 成功获取到ID后退出函数
+            else:
+                print(f"Failed to retrieve latest ID: {response.status_code}")
+        except Exception as e:
+            print(f"An error occurred while fetching the latest ID: {e}")
+
+        attempt += 1
+        sleep_time = backoff_factor * (2**attempt)
+        print(f"Retrying in {sleep_time} seconds...")
+        time.sleep(sleep_time)
+
+    print(f"Failed to retrieve latest ID after {max_retries} attempts")
+
+
+def update_latest_id():
+    while True:
+        fetch_latest_id()
+        time.sleep(60)
+
+
+def fetch_data(max_retries=3, retry_delay=2):
+    while True:
+        url = url_queue.get()  # get url from url_queue
+        if url is None:
+            break
+
+        retry_count = 0
+        while retry_count < max_retries:
+            try:
+                response = requests.get(url)
+                if response.status_code == 200:
+                    data = response.json()
+                    data_queue.put(data)
+                    break  # 成功的请求，无需重试，跳出重试循环
+                else:
+                    print(f"Failed to fetch data from {url}: {response.status_code}")
+                    retry_count += 1
+                    time.sleep(retry_delay)
+
+            except Exception as e:
+                retry_count += 1
+                print(
+                    f"An error occurred while fetching data from {url}: {e}. Retrying in {retry_delay} seconds..."
+                )
+                time.sleep(retry_delay)
+
+        url_queue.task_done()
+
+
+# create 16 threads to fetch data
+threads = []
+for _ in range(args.workers):
+    thread = threading.Thread(target=fetch_data)
+    thread.daemon = True
+    thread.start()
+    threads.append(thread)
+
+# 启动线程来定期更新最新 ID
+id_update_thread = threading.Thread(target=update_latest_id)
+id_update_thread.daemon = True
+id_update_thread.start()
+
+required_columns = [col.name for col in t_posts.columns if not col.primary_key]
+
+danbooru_engine = get_engine("danbooru_metadata.db")
+t_posts.metadata.create_all(danbooru_engine)
+
+# 获取数据库中最大的 ID
+with danbooru_engine.connect() as conn:
+    res = conn.execute(text("SELECT MAX(id) FROM posts"))
+    latest_id = res.fetchone()[0] or 1
+
+start_id = args.start_id
+print("start_id:", start_id)
+
+
+def save_data():
+    while True:
+        data = data_queue.get()
+        for column in required_columns:
+            for d in data:
+                if column not in d:
+                    d[column] = None
+        with danbooru_engine.connect() as conn:
+            conn.execute(t_posts.insert().prefix_with("OR REPLACE"), data)
+            conn.commit()
+
+
+save_thread = threading.Thread(target=save_data)
+save_thread.daemon = True
+save_thread.start()
+
+
+try:
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(),
+        TextColumn("[{task.completed} / {task.total}]"),
+    ) as progress:
+        # 添加一个任务，注意 total 参数设置为 latest_id
+        task = progress.add_task(
+            "Processing", start=True, total=latest_id - start_id + 1
+        )
+        current_id = start_id
+
+        while True:
+            if current_id >= latest_id:
+                progress.update(task, completed=latest_id)  # 确保进度条满格
+                sleep(2)
+                continue
+
+            url = base_api_url.format(current_id, API_KEY, LOGIN)
+            url_queue.put(url)  # 将生成的 URL 放入 URL ��列
+            current_id += 200
+            progress.update(task, completed=current_id, total=latest_id)
+            sleep(0.1)
+except KeyboardInterrupt:
+    print("Stopped by user")
+    exit(0)