Adapted balance tags script to the new JSON format.

balance_tags.py

@@ -33,20 +33,20 @@ def main():
     print("Starting...\nGetting model tags...")
     model_tags = utils.get_model_tags(MODEL_TAGS_PATH)
     print("Getting paths...")
-    image_id_image_tags_path_tuple_tuple_list = sorted(utils.get_image_id_image_tags_path_tuple_dict(IMAGE_DIR).items(), key=lambda x: x[0])
-    print("Got", len(image_id_image_tags_path_tuple_tuple_list), "images.\nShuffling paths...")
+    image_id_image_metadata_path_tuple_tuple_list = sorted(utils.get_image_id_image_metadata_path_tuple_dict(IMAGE_DIR).items(), key=lambda x: x[0])
+    print("Got", len(image_id_image_metadata_path_tuple_tuple_list), "images.\nShuffling paths...")
     random.seed(42)
-    random.shuffle(image_id_image_tags_path_tuple_tuple_list)
+    random.shuffle(image_id_image_metadata_path_tuple_tuple_list)
     print("Making buckets...")
     in_bucket_image_count = 0
     buckets = {tag: [] for tag in model_tags}
-    for image_id_image_tags_path_tuple_tuple in tqdm.tqdm(image_id_image_tags_path_tuple_tuple_list, desc="Making buckets"):
+    for image_id_image_metadata_path_tuple_tuple in tqdm.tqdm(image_id_image_metadata_path_tuple_tuple_list, desc="Making buckets"):
         did_append = False
-        for tag in utils.get_tags_set(image_id_image_tags_path_tuple_tuple[1][1]):
+        for tag in utils.get_tags(image_id_image_metadata_path_tuple_tuple[1][1]):
             bucket = buckets.get(tag)
             if bucket is None:
                 continue
-            bucket.append(image_id_image_tags_path_tuple_tuple)
+            bucket.append(image_id_image_metadata_path_tuple_tuple)
             did_append = True
         if did_append:
             in_bucket_image_count += 1
@@ -59,33 +59,33 @@ def main():
         return
     print("Selecting...")
     total = min(args.count, in_bucket_image_count)
-    selected = {} # Key: Image ID, Value: Tuple(Image path, Tags path).
+    selected = {} # Key: Image ID, Value: (Image path, Metadata path).
     with tqdm.tqdm(total=total, desc="Selecting") as progress_bar:
         while len(selected) < total:
-            for tag, image_id_image_tags_path_tuple_tuple_list in buckets:
+            for tag, image_id_image_metadata_path_tuple_tuple_list in buckets:
                 if len(selected) >= total:
                     break
-                if len(image_id_image_tags_path_tuple_tuple_list) <= 0:
+                if len(image_id_image_metadata_path_tuple_tuple_list) <= 0:
                     continue
-                for i in range(len(image_id_image_tags_path_tuple_tuple_list) - 1, -1, -1):
-                    if image_id_image_tags_path_tuple_tuple_list[i][0] in selected:
-                        del image_id_image_tags_path_tuple_tuple_list[i]
+                for i in range(len(image_id_image_metadata_path_tuple_tuple_list) - 1, -1, -1):
+                    if image_id_image_metadata_path_tuple_tuple_list[i][0] in selected:
+                        del image_id_image_metadata_path_tuple_tuple_list[i]
                         break
                 else:
-                    last_item = image_id_image_tags_path_tuple_tuple_list[-1]
+                    last_item = image_id_image_metadata_path_tuple_tuple_list[-1]
                     selected[last_item[0]] = last_item[1]
-                    del image_id_image_tags_path_tuple_tuple_list[-1]
+                    del image_id_image_metadata_path_tuple_tuple_list[-1]
                     progress_bar.update(1)
     print("Selected", len(selected), "images.\nDeleting unselected images...")
     temp_dir = "__tag_bal_trans_tmp__"
     if os.path.exists(temp_dir):
         shutil.rmtree(temp_dir)
     os.makedirs(temp_dir)
-    for image_tags_path_tuple in tqdm.tqdm(selected.values(), desc="Moving"):
-        image_path = image_tags_path_tuple[0]
-        tags_path = image_tags_path_tuple[1]
+    for image_metadata_path_tuple in tqdm.tqdm(selected.values(), desc="Moving"):
+        image_path = image_metadata_path_tuple[0]
+        metadata_path = image_metadata_path_tuple[1]
         os.rename(image_path, os.path.join(temp_dir, os.path.basename(image_path)))
-        os.rename(tags_path, os.path.join(temp_dir, os.path.basename(tags_path)))
+        os.rename(metadata_path, os.path.join(temp_dir, os.path.basename(metadata_path)))
     shutil.rmtree(IMAGE_DIR)
     shutil.move(temp_dir, IMAGE_DIR)
     print("Finished.")

scrape_gel.py

@@ -4,16 +4,15 @@ import sys
 import time
 import json
 import utils
-import urllib
 import asyncio
-import aiohttp
 import aiofiles
 import argparse
 import concurrent
-import html as libhtml
 from constants import *
 from bs4 import BeautifulSoup
 
+IMAGE_ID_PATTERN = re.compile(r"id=(\d+)")
+
 def get_type_tags_dict(soup):
     tag_ul = soup.find("ul", id="tag-list")
     if not tag_ul:
@@ -40,11 +39,10 @@ def get_type_tags_dict(soup):
     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)
-    image_id_int = int(image_id)
-    scrape_state.last_reached_image_id = image_id_int
+    image_id = IMAGE_ID_PATTERN.search(scrape_args.target).group(1)
+    scrape_state.last_reached_image_id = image_id
     image_id_already_exists = image_id in scrape_state.existing_image_ids
-    if image_id_already_exists and image_id_int % 100 < 99:
+    if image_id_already_exists and not image_id.endswith("99"):
         # print(f"Image {image_id} already exists, skipped.")
         return
     scrape_state.existing_image_ids.add(image_id)
@@ -59,50 +57,61 @@ async def process_link(scrape_args, scrape_state):
                 html = await response.text()
             query_used_time = time.time() - query_start_time
             soup = BeautifulSoup(html, "html.parser")
+
+            video_container = soup.find("video", id="gelcomVideoPlayer")
+            if video_container:
+                print(f"Image {image_id} is a video, skipped.")
+                return
+            image_container = soup.find("section", class_=["image-container", "note-container"])
+            if not image_container:
+                raise RuntimeError("No image container found.")
+
             score_span = soup.find("span", id="psc" + image_id)
             try:
                 image_score = int(score_span.contents[0])
             except (AttributeError, IndexError, ValueError) as e:
-                raise RuntimeError("Error while getting the image score: " + str(e))
+                raise RuntimeError("Error while getting the image score: " + str(e)) from e
             scrape_state.last_reached_image_score = image_score
             if image_id_already_exists:
                 # print(f"Image {image_id} already exists, skipped.")
                 return
-            video_container = soup.find("video", id="gelcomVideoPlayer")
-            if video_container:
-                print(f"Image {image_id} is a video, skipped.")
-                return
-            image_container = soup.find("section", class_=["image-container", "note-container"])
-            if not image_container:
-                raise RuntimeError("No image container found.")
+
             if not scrape_args.use_low_quality:
                 image_download_url = soup.find("a", string="Original image")["href"]
             else:
                 image_download_url = image_container.find("img", id="image")["src"]
+
             image_ext = os.path.splitext(image_download_url)[1].lower()
             if image_ext not in IMAGE_EXT:
                 print(f"Image {image_id} is not an image, skipped.")
                 return
+
             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.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)
             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(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
@@ -116,8 +125,8 @@ async def process_link(scrape_args, scrape_state):
             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]"
+                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]
@@ -130,7 +139,10 @@ async def process_link(scrape_args, scrape_state):
             await asyncio.sleep(0.1)
     if not image_id_already_exists:
         scrape_state.existing_image_ids.remove(image_id)
-    print(f"All retry attempts failed, image {image_id} skipped. Final error {error.__class__.__name__}: {error}")
+    if error is not None:
+        print(f"All retry attempts failed, image {image_id} skipped. Final error {error.__class__.__name__}: {error}")
+    else:
+        print(f"Task for image {image_id} cancelled.")
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Scrape images from Gelbooru.")

utils/scrape_state.py

@@ -9,7 +9,7 @@ class ScrapeState:
     session: ThreadPoolExecutor
     existing_image_ids: set[str] = field(default_factory=set)
     scraped_image_count: int = 0
-    last_reached_image_id: Optional[int] = None
+    last_reached_image_id: Optional[str] = None
     last_reached_image_score: Optional[int] = None
     avg_query_time: list[float, int] = field(default_factory=lambda: [0.0, 0])
     avg_download_time: list[float, int] = field(default_factory=lambda: [0.0, 0])

utils/search_tags.py

@@ -51,10 +51,10 @@ class CompareFilterTag:
     compare_type: str
     less_than: bool
     with_equal: bool
-    target: int
+    target: str
 
     def __str__(self):
-        return self.compare_type + ":" + ("<" if self.less_than else ">") + ("=" if self.with_equal else "") + str(self.target)
+        return self.compare_type + ":" + ("<" if self.less_than else ">") + ("=" if self.with_equal else "") + self.target
 
     @classmethod
     def from_tag(cls, tag):
@@ -70,17 +70,7 @@ class CompareFilterTag:
             if not with_equal:
                 return None
             raise ValueError(f"The compare filter tag \"{tag}\" you provided isn't valid!")
-        try:
-            target = int(target)
-        except ValueError as e:
-            raise ValueError(f"The compare filter tag \"{tag}\" you provided isn't valid!") from e
-        if less_than == "<":
-            less_than = True
-        else:
-            less_than = False
-        with_equal = bool(with_equal)
-        compare_type = re_match.group(1)
-        return cls(compare_type, less_than, with_equal, target)
+        return cls(re_match.group(1), less_than == "<", bool(with_equal), target)
 
 class SearchTags:
 
@@ -125,7 +115,9 @@ class SearchTags:
             case "score":
                 if scrape_state.last_reached_image_score is None:
                     raise ValueError("Last reached image score isn't set!")
-                self.sort_associated_compare_filter_tag = CompareFilterTag("score", self.sort_tag.descending, True, scrape_state.last_reached_image_score)
+                self.sort_associated_compare_filter_tag = CompareFilterTag("score", self.sort_tag.descending, True, str(scrape_state.last_reached_image_score))
+            case _:
+                raise NotImplementedError(f"Bound update for sort type \"{self.sort_tag.sort_type}\" is not implemented!")
 
     def to_search_string(self):
         tag_texts = [str(self.sort_tag)]