Gelbooru scraper now saves JSON instead of TXT.

compress.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import utils
 import argparse
 import tarfile
 from constants import *
@@ -7,18 +8,15 @@ import concurrent.futures
 
 def compress_chunk(chunk, chunk_index, output_dir):
     with tarfile.open(os.path.join(output_dir, f"chunk_{chunk_index}.tar"), "w") as tar:
-        for image_path in chunk:
-            tags_path = os.path.splitext(image_path)[0] + ".txt"
-            if not os.path.isfile(tags_path):
-                continue
+        for image_path, metadata_path in chunk:
             tar.add(image_path, arcname=os.path.basename(image_path))
-            tar.add(tags_path, arcname=os.path.basename(tags_path))
+            tar.add(metadata_path, arcname=os.path.basename(metadata_path))
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Group images into uncompressed tar files.")
     parser.add_argument("-i", "--input-dir", default=IMAGE_DIR, help="Input directory for the images to chunk into tars")
     parser.add_argument("-o", "--output-dir", default=COMPRESSED_DIR, help="Output directory for chunked tars")
-    parser.add_argument("-n", "--num-images-per-chunk", type=int, default=1024, help="Number of images per chunk, default to 1024")
+    parser.add_argument("-n", "--num-images-per-chunk", type=int, default=sys.maxsize, help="Number of images per chunk, default to infinite")
     args = parser.parse_args()
     if args.num_images_per_chunk < 1:
         print("Number of images per chunk needs to be a positive integer!")
@@ -27,16 +25,12 @@ def parse_args():
 
 def main():
     args = parse_args()
-    if not os.path.isdir(args.input_dir):
-        print(f"Your input dir \"{args.input_dir}\" doesn't exist or isn't a directory!")
-        sys.exit(1)
-    image_files = [os.path.join(args.input_dir, f) for f in os.listdir(args.input_dir) if not f.endswith(".txt")]
-    image_files.sort()
+    image_metadata_path_tuple_list = [e[1] for e in sorted(utils.get_image_id_image_metadata_path_tuple_dict(args.input_dir).items(), key=lambda x: x[0])]
     os.makedirs(args.output_dir, exist_ok=True)
     with concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count()) as executor:
         futures = []
-        for i in range(0, len(image_files), args.num_images_per_chunk):
-            chunk = image_files[i:i + args.num_images_per_chunk]
+        for i in range(0, len(image_metadata_path_tuple_list), args.num_images_per_chunk):
+            chunk = image_metadata_path_tuple_list[i:i + args.num_images_per_chunk]
             chunk_index = i // args.num_images_per_chunk
             future = executor.submit(compress_chunk, chunk, chunk_index, args.output_dir)
             futures.append(future)

scrape_gel.py

@@ -2,8 +2,8 @@ import os
 import re
 import sys
 import time
+import json
 import utils
-import random
 import urllib
 import asyncio
 import aiohttp
@@ -13,13 +13,13 @@ import concurrent
 import html as libhtml
 from constants import *
 from bs4 import BeautifulSoup
-from collections import defaultdict
 
-def get_tags(soup, preserve_meta_tags):
+def get_type_tags_dict(soup):
     tag_ul = soup.find("ul", id="tag-list")
     if not tag_ul:
         raise RuntimeError("No tag list found in this web page!")
-    type_tag_list_dict = defaultdict(list)
+    type_tags_dict = {}
+    tags_in_dict = set()
     for element in tag_ul.find_all("li"):
         class_name = element.get("class")
         if not class_name or len(class_name) != 1:
@@ -27,21 +27,17 @@ def get_tags(soup, preserve_meta_tags):
         class_name = class_name[0]
         if not class_name.startswith("tag-type-"):
             continue
-        type_tag_list_dict[class_name[9:]].append(element.find("a", recursive=False).contents[0].replace("_", " "))
-    tags = []
-    for type, tag_list in type_tag_list_dict.items():
-        if not preserve_meta_tags:
-            match type:
-                case "copyright":
-                    if "minecraft" in tag_list:
-                        tags.append("minecraft")
-                    continue
-                case "artist":
-                    continue
-                case "metadata":
-                    continue
-        tags += tag_list
-    return tags
+        tag = element.find("a", recursive=False).contents[0].replace(" ", "_").strip(",_")
+        if tag in tags_in_dict:
+            continue
+        tag_type = class_name[9:]
+        tag_list = type_tags_dict.get(tag_type)
+        if tag_list is None:
+            type_tags_dict[tag_type] = [tag]
+        else:
+            tag_list.append(tag)
+        tags_in_dict.add(tag)
+    return type_tags_dict, len(tags_in_dict)
 
 async def process_link(scrape_args, scrape_state):
     image_id = re.search(r"id=(\d+)", scrape_args.target).group(1)
@@ -64,8 +60,11 @@ async def process_link(scrape_args, scrape_state):
             query_used_time = time.time() - query_start_time
             soup = BeautifulSoup(html, "html.parser")
             score_span = soup.find("span", id="psc" + image_id)
-            if score_span:
-                scrape_state.last_reached_image_score = int(score_span.contents[0])
+            try:
+                image_score = int(score_span.contents[0])
+            except (AttributeError, IndexError, ValueError) as e:
+                raise RuntimeError("Error while getting the image score: " + str(e))
+            scrape_state.last_reached_image_score = image_score
             if image_id_already_exists:
                 # print(f"Image {image_id} already exists, skipped.")
                 return
@@ -84,45 +83,44 @@ async def process_link(scrape_args, scrape_state):
             if image_ext not in IMAGE_EXT:
                 print(f"Image {image_id} is not an image, skipped.")
                 return
-            tags = get_tags(soup, scrape_args.preserve_meta_tags)
-            tag_count = len(tags)
+            type_tags_dict, tag_count = get_type_tags_dict(soup)
             if tag_count < scrape_args.min_tags:
                 # print(f"Image {image_id} doesn't have enough tags({tag_count} < {scrape_args.min_tags}), skipped.")
                 return
-            rating = image_container["data-rating"]
-            if rating == "explicit": tags.append("nsfw")
-            elif rating == "questionable": tags.append("qfw")
-            else: tags.append("sfw")
-            random.shuffle(tags)
+            rating = image_container.get("data-rating")
+            if not rating:
+                raise RuntimeError("No rating found.")
+            if rating == "safe":
+                rating = "general"
+            metadata = json.dumps({"image_id": image_id, "score": image_score, "rating": rating, "tags": type_tags_dict}, ensure_ascii=False, separators=(",", ":"))
             image_path = os.path.join(IMAGE_DIR, image_id + image_ext)
-            tags_path = os.path.join(IMAGE_DIR, image_id + ".txt")
-            tags_text = ", ".join(tags)
+            metadata_path = os.path.join(IMAGE_DIR, image_id + ".json")
             download_start_time = time.time()
             async with scrape_state.session.get(image_download_url) as img_response:
                 img_data = await img_response.read()
             download_used_time = time.time() - download_start_time
             async with aiofiles.open(image_path, "wb") as f:
                 await f.write(img_data)
-            async with aiofiles.open(tags_path, "w", encoding="utf8") as f:
-                await f.write(tags_text)
-            if not await utils.submit_validation(scrape_state.thread_pool, image_path, tags_path, scrape_args.width, scrape_args.height, scrape_args.convert_to_avif):
-                scrape_state.existing_image_ids.remove(image_id)
-            else:
-                scrape_state.scraped_image_count += 1
-                total_query_time = scrape_state.avg_query_time[0] * scrape_state.avg_query_time[1] + query_used_time
-                total_download_time = scrape_state.avg_download_time[0] * scrape_state.avg_download_time[1] + download_used_time
-                scrape_state.avg_query_time[1] += 1
-                scrape_state.avg_download_time[1] += 1
-                scrape_state.avg_query_time[0] = total_query_time / scrape_state.avg_query_time[1]
-                scrape_state.avg_download_time[0] = total_download_time / scrape_state.avg_download_time[1]
-                interval = 1000
-                if scrape_state.scraped_image_count % interval == 0:
-                    print(
-                        f"Scraped {scrape_state.scraped_image_count}/{scrape_args.max_scrape_count} images, "
-                        f"stats for the last {interval} images: [Average query time: {scrape_state.avg_query_time[0]:.3f}s | Average download time: {scrape_state.avg_download_time[0]:.3f}s]"
-                    )
-                    scrape_state.avg_query_time = [0.0, 0]
-                    scrape_state.avg_download_time = [0.0, 0]
+            async with aiofiles.open(metadata_path, "w", encoding="utf8") as f:
+                await f.write(metadata)
+            if not await utils.submit_validation(scrape_state.thread_pool, image_path, metadata_path, scrape_args.width, scrape_args.height, scrape_args.convert_to_avif):
+                return
+            scrape_state.scraped_image_count += 1
+            total_query_time = scrape_state.avg_query_time[0] * scrape_state.avg_query_time[1] + query_used_time
+            total_download_time = scrape_state.avg_download_time[0] * scrape_state.avg_download_time[1] + download_used_time
+            scrape_state.avg_query_time[1] += 1
+            scrape_state.avg_download_time[1] += 1
+            scrape_state.avg_query_time[0] = total_query_time / scrape_state.avg_query_time[1]
+            scrape_state.avg_download_time[0] = total_download_time / scrape_state.avg_download_time[1]
+            interval = 1000
+            if scrape_state.scraped_image_count % interval != 0:
+                return
+            print(
+                f"Scraped {scrape_state.scraped_image_count}/{scrape_args.max_scrape_count} images, "
+                f"stats for the last {interval} images: [Average query time: {scrape_state.avg_query_time[0]:.3f}s | Average download time: {scrape_state.avg_download_time[0]:.3f}s]"
+            )
+            scrape_state.avg_query_time = [0.0, 0]
+            scrape_state.avg_download_time = [0.0, 0]
             return
         except Exception as e:
             error = e
@@ -142,7 +140,6 @@ def parse_args():
     parser.add_argument("-a", "--avif", action="store_true", help="If set, will convert the image into avif, need to have pillow-avif-plugin installed")
     parser.add_argument("-l", "--low-quality", action="store_true", help="If set, will download the sample instead of the original image")
     parser.add_argument("-t", "--min-tags", type=int, default=0, help="Filter out images with less than the specified amount of tags, default to 0")
-    parser.add_argument("-p", "--preserve-meta-tags", action="store_true", help="Preserve artist, copyright, and metadata tags")
     parser.add_argument("-m", "--max-scrape-count", type=int, help="Stop after scraping the set amount of images, may not be exact because of the asynchronous nature of this script, default to infinite")
     parser.add_argument("-c", "--continuous-scraping", action="store_true", help="If set, will scraping continuously even when reaching the 20000 images Gelbooru search depth cap by adjusting search tags")
     parser.add_argument("tags_to_search", nargs=argparse.REMAINDER, help="List of tags to search for, default to all")
@@ -170,8 +167,6 @@ def parse_args():
     if isinstance(args.max_scrape_count, int) and args.max_scrape_count <= 0:
         print("Maximum scrape count must be greater than 0!")
         sys.exit(1)
-    if not args.tags_to_search:
-        args.tags_to_search = ["all"]
     return args
 
 async def main():
@@ -225,9 +220,7 @@ async def main():
                         if task.done():
                             await task
                             del tasks[i]
-                tasks.append(asyncio.create_task(process_link(
-                    utils.ScrapeArgs(image_url, args.width, args.height, args.avif, args.low_quality, args.min_tags, args.preserve_meta_tags, args.max_scrape_count), scrape_state
-                )))
+                tasks.append(asyncio.create_task(process_link(utils.ScrapeArgs(image_url, args.width, args.height, args.avif, args.low_quality, args.min_tags, args.max_scrape_count), scrape_state)))
             if utils.get_sigint_count() >= 1 or isinstance(args.max_scrape_count, int) and scrape_state.scraped_image_count >= args.max_scrape_count:
                 break
             session_refresh_counter += 1

utils/scrape_args.py

@@ -9,5 +9,4 @@ class ScrapeArgs:
     convert_to_avif: bool = False
     use_low_quality: bool = False
     min_tags: int = 0
-    preserve_meta_tags: bool = False
     max_scrape_count: Optional[int] = None

utils/utils.py

@@ -3,7 +3,7 @@ import asyncio
 import aiohttp
 from PIL import Image
 
-def validate_image(image_path, tags_path, width=None, height=None, convert_to_avif=False):
+def validate_image(image_path, metadata_path, width=None, height=None, convert_to_avif=False):
     new_path = None
     try:
         with Image.open(image_path) as img:
@@ -30,10 +30,10 @@ def validate_image(image_path, tags_path, width=None, height=None, convert_to_av
         except Exception as e:
             print("Error deleting image file:", e)
         try:
-            os.remove(tags_path)
-            print(f"Deleted invalid image and tags files: {image_path}, {tags_path}")
+            os.remove(metadata_path)
+            print(f"Deleted invalid image and metadata files: {image_path}, {metadata_path}")
         except Exception as e:
-            print("Error deleting tags file:", e)
+            print("Error deleting metadata file:", e)
         try:
             if new_path is not None and os.path.isfile(new_path):
                 os.remove(new_path)
@@ -42,28 +42,28 @@ def validate_image(image_path, tags_path, width=None, height=None, convert_to_av
             print("Error deleting new image file:", e)
     return False
 
-async def submit_validation(thread_pool, image_path, tags_path, width=None, height=None, convert_to_avif=False):
-    return await asyncio.wrap_future(thread_pool.submit(validate_image, image_path, tags_path, width, height, convert_to_avif))
+async def submit_validation(thread_pool, image_path, metadata_path, width=None, height=None, convert_to_avif=False):
+    return await asyncio.wrap_future(thread_pool.submit(validate_image, image_path, metadata_path, width, height, convert_to_avif))
 
-def get_image_id_image_tags_path_tuple_dict(image_dir):
+def get_image_id_image_metadata_path_tuple_dict(image_dir):
     if not os.path.isdir(image_dir):
         raise FileNotFoundError(f"\"{image_dir}\" is not a directory!")
-    image_id_image_tags_path_tuple_dict = {}
+    image_id_image_metadata_path_tuple_dict = {}
     for path in os.listdir(image_dir):
         image_id, ext = os.path.splitext(path)
-        if ext == ".txt":
+        if ext == ".json":
             continue
         path = os.path.join(image_dir, path)
         if not os.path.isfile(path):
             continue
-        tags_path = os.path.splitext(path)[0] + ".txt"
-        if not os.path.isfile(tags_path):
+        metadata_path = os.path.splitext(path)[0] + ".json"
+        if not os.path.isfile(metadata_path):
             continue
-        image_id_image_tags_path_tuple_dict[image_id] = (path, tags_path)
-    return image_id_image_tags_path_tuple_dict
+        image_id_image_metadata_path_tuple_dict[image_id] = (path, metadata_path)
+    return image_id_image_metadata_path_tuple_dict
 
 def get_existing_image_id_set(image_dir):
-    return set(get_image_id_image_tags_path_tuple_dict(image_dir))
+    return set(get_image_id_image_metadata_path_tuple_dict(image_dir))
 
 def get_session(timeout=None, cookies=None):
     kwargs = {"connector": aiohttp.TCPConnector(limit=0, ttl_dns_cache=600), "cookies": cookies}
@@ -88,18 +88,27 @@ def get_model_tags(model_tags_path):
         raise ValueError(f"The index specified in \"{model_tags_path}\" is not continuous!")
     return [tag for _, tag in sorted_index_tag_tuple_list]
 
-def get_tags_set(tags_path):
-    if not os.path.isfile(tags_path):
-        raise FileNotFoundError(f"\"{tags_path}\" is not a file!")
-    with open(tags_path, "r", encoding="utf8") as tags_file:
-        tags_text = tags_file.read()
-    tags_set = set()
-    for tag in tags_text.split(","):
-        tag = tag.strip()
-        if tag:
-            tag = tag.replace(" ", "_")
-            if tag == "nsfw": tag = "rating:explicit"
-            elif tag == "qfw": tag = "rating:questionable"
-            elif tag == "sfw": tag = "rating:safe"
-            tags_set.add(tag)
-    return tags_set
+def get_metadata(metadata_path):
+    if not os.path.isfile(metadata_path):
+        raise FileNotFoundError(f"\"{metadata_path}\" is not a file!")
+    with open(metadata_path, "r", encoding="utf8") as metadata_file:
+        return json.load(metadata_file)
+
+def get_tags(metadata_path, exclude=None, include=None):
+    if exclude is not None and include is not None:
+        raise ValueError("You can't set both exclude and include, please only set one.")
+    metadata = get_metadata(metadata_path)
+    tags = ["rating:" + metadata["rating"]]
+    type_tags_dict = metadata.get("tags")
+    if not type_tags_dict:
+        return tags
+    if exclude is not None:
+        for e in exclude:
+            type_tags_dict.pop(e, None)
+    elif include is not None:
+        for k in list(type_tags_dict):
+            if k not in include:
+                type_tags_dict.pop(k)
+    for l in type_tags_dict.values():
+        tags += l
+    return tags