Finished the scraping script.

.gitignore

@@ -0,0 +1,3 @@
+images/
+__pycache__/
+.ipynb_checkpoints/

README.md

@@ -1,3 +1,5 @@
 ---
 license: mit
 ---
+# Anime Collection
+A repo containing scripts to scrape Gelbooru and images scraped from it.

scrape.py

@@ -0,0 +1,192 @@
+import os
+import re
+import sys
+import random
+import urllib
+import signal
+import asyncio
+import aiohttp
+import aiofiles
+import argparse
+import concurrent
+from PIL import Image
+from bs4 import BeautifulSoup
+
+MAX_TASKS = 50
+MAX_RETRY = 3
+IMAGE_DIR = "images"
+IMAGE_EXT = {
+    ".png", ".jpg", ".jpeg", ".bmp", ".tiff", ".tif", 
+    ".webp", ".heic", ".heif", ".avif", ".jxl",
+}
+
+SIGINT_COUNTER = 0
+
+def sigint_handler(signum, frame):
+    global SIGINT_COUNTER
+    SIGINT_COUNTER += 1
+    print()
+    if SIGINT_COUNTER >= 3:
+        print("Script force quit by user, exiting...")
+        sys.exit(1)
+
+def validate_image(image_path, tag_path):
+    try:
+        with Image.open(image_path) as img:
+            img.verify()
+        return True
+    except Exception as e:
+        print(f"Error validating image {image_path}: {e}")
+        return False
+
+def handle_validation_result(future, image_path, tag_path):
+    if future.result():
+        return
+    try:
+        os.remove(image_path)
+    except Exception as e:
+        print(f"Error deleting image file: {e}")
+    try:
+        os.remove(tag_path)
+        print(f"Deleted invalid image and tag files: {image_path}, {tag_path}")
+    except Exception as e:
+        print(f"Error deleting tags file: {e}")
+
+async def process_link(image_url, image_ids_to_ignore, session, thread_pool):
+    image_id = re.search("id=(\d+)", image_url).group(1)
+    if image_id in image_ids_to_ignore:
+        # print(f"Image {image_id} already exists, skipped.")
+        return
+    for i in range(1, MAX_RETRY + 2): # 1 indexed.
+        try:
+            if SIGINT_COUNTER >= 1:
+                break
+            # print(f"Processing image {image_id}...")
+            async with session.get(image_url) as response:
+                html = await response.text()
+            soup = BeautifulSoup(html, "html.parser")
+            image_container = soup.find("section", class_=["image-container", "note-container"])
+            if not image_container:
+                raise RuntimeError(f"No image container found for {image_id}.")
+            original_link = soup.find("a", string="Original image")["href"]
+            image_ext = os.path.splitext(original_link)[1].lower()
+            if not image_ext:
+                print(f"Image {image_id} has no file extension, skipped.")
+                return
+            if image_ext not in IMAGE_EXT:
+                print(f"Image {image_id} is not an image, skipped.")
+                return
+            tags = image_container["data-tags"].strip().split()
+            rating = image_container["data-rating"]
+            tags.append("nsfw" if rating in {"explicit", "questionable"} else "sfw")
+            random.shuffle(tags)
+            async with session.get(original_link) as img_response:
+                img_data = await img_response.read()
+            image_path = os.path.join(IMAGE_DIR, image_id + image_ext)
+            os.makedirs(IMAGE_DIR, exist_ok=True)
+            async with aiofiles.open(image_path, "wb") as f:
+                await f.write(img_data)
+            tag_path = os.path.join(IMAGE_DIR, image_id + ".txt")
+            async with aiofiles.open(tag_path, "w", encoding="utf8") as f:
+                await f.write(", ".join(tag.replace("_", " ") for tag in tags))
+            future = thread_pool.submit(validate_image, image_path, tag_path)
+            future.add_done_callback(lambda x: handle_validation_result(x, image_path, tag_path))
+            return
+        except Exception as e:
+            if i > MAX_RETRY:
+                break
+            # print(f"A {e.__class__.__name__} occurred with image {image_id}: {e}\nPausing for 0.1 second before retrying attempt {i}/{MAX_RETRY}...")
+            await asyncio.sleep(0.1)
+    print(f"All retry attempts failed, image {image_id} skipped.")
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Scrape images from Gelbooru.")
+    parser.add_argument("-s", "--site", type=str, default="https://gelbooru.com", help="Domain to scrape from, defaults to https://gelbooru.com")
+    parser.add_argument("tags_to_search", nargs=argparse.REMAINDER, help="List of tags to search for, defaults to all")
+    args = parser.parse_args()
+    if not args.tags_to_search:
+        args.tags_to_search = ["all"]
+    return args
+
+async def main():
+    args = parse_args()
+    print("Starting...")
+    page_number = 0
+    search_tags = "+".join(urllib.parse.quote(tag, safe="") for tag in args.tags_to_search)
+
+    image_ids_to_ignore = set()
+    if os.path.isdir(IMAGE_DIR):
+        for path in os.listdir(IMAGE_DIR):
+            image_id, ext = os.path.splitext(path)
+            if ext != ".txt":
+                continue
+            image_ids_to_ignore.add(image_id)
+
+    signal.signal(signal.SIGINT, sigint_handler)
+
+    async with aiohttp.ClientSession(cookies={"fringeBenefits": "yup"}, timeout=aiohttp.ClientTimeout(total=10)) as session:
+        thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count())
+        tasks = []
+        while True:
+            try:
+                if SIGINT_COUNTER >= 1:
+                    break
+                request_url = f"{args.site}/index.php?page=post&s=list&tags={search_tags}&pid={page_number}"
+                print(f"Going to {request_url}")
+                async with session.get(request_url) as response:
+                    html = await response.text()
+                soup = BeautifulSoup(html, "html.parser")
+                thumbnails_div = soup.find("div", class_="thumbnail-container")
+                if not thumbnails_div:
+                    raise RuntimeError("Thumbnails division not found.")
+                image_urls = [a["href"] for a in thumbnails_div.find_all("a")]
+                image_url_count = len(image_urls)
+                if image_url_count == 0:
+                    print("Website returned 0 image urls.")
+                    break
+                print(f"Got {image_url_count} posts.")
+                page_number += image_url_count
+                for image_url in image_urls:
+                    if SIGINT_COUNTER >= 1:
+                        break
+                    while len(tasks) >= MAX_TASKS:
+                        if SIGINT_COUNTER >= 1:
+                            break
+                        await asyncio.sleep(0.1)
+                        for i in range(len(tasks) - 1, -1, -1):
+                            task = tasks[i]
+                            if task.done():
+                                await task
+                                del tasks[i]
+                    tasks.append(asyncio.create_task(process_link(image_url, image_ids_to_ignore, session, thread_pool)))
+            except Exception as e:
+                print(f"An error occurred: {e}\nPausing for 0.1 second before retrying...")
+                await asyncio.sleep(0.1)
+        if SIGINT_COUNTER >= 1:
+            print("Script interrupted by user, gracefully exiting...\nYou can interrupt again to exit semi-forcefully, but it will break image checks!")
+        else:
+            print("No more images to download, waiting already submitted tasks to finish...")
+        while tasks and SIGINT_COUNTER <= 1:
+            await asyncio.sleep(0.1)
+            for i in range(len(tasks) - 1, -1, -1):
+                task = tasks[i]
+                if task.done():
+                    await task
+                    del tasks[i]
+        while True:
+            if SIGINT_COUNTER >= 2:
+                print("Another interrupt received, exiting semi-forcefully...\nYou can interrupt again for truly forceful exit, but it most likely will break a lot of things!")
+                thread_pool.shutdown(cancel_futures=True)
+                break
+            await asyncio.sleep(0.1)
+            if not thread_pool._work_queue.qsize():
+                break
+    if SIGINT_COUNTER >= 2:
+        sys.exit(1)
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nScript interrupted by user, exiting...")
+        sys.exit(1)