Added continuous scraping for Gelbooru.

scrape_gel.py

@@ -13,39 +13,49 @@ import html as libhtml
 from constants import *
 from bs4 import BeautifulSoup
 
-async def process_link(thread_pool, session, image_url, image_ids_to_ignore, width, height, convert_to_avif, use_low_quality, min_tags):
-    image_id = re.search("id=(\d+)", image_url).group(1)
-    if image_id in image_ids_to_ignore:
+async def process_link(scrape_args, scrape_state):
+    image_id = re.search("id=(\d+)", scrape_args.target).group(1)
+    image_id_int = int(image_id)
+    scrape_state.last_reached_image_id = image_id_int
+    image_id_already_exists = image_id in scrape_state.existing_image_ids
+    if image_id_already_exists and image_id_int % 100 < 99:
         # print(f"Image {image_id} already exists, skipped.")
         return
-    image_ids_to_ignore.add(image_id)
+    scrape_state.existing_image_ids.add(image_id)
     error = None
     for i in range(1, MAX_RETRY + 2): # 1 indexed.
         try:
-            if utils.get_sigint_count() >= 1:
+            if utils.get_sigint_count() >= 1 or isinstance(scrape_args.max_scrape_count, int) and scrape_state.scraped_image_count >= scrape_args.max_scrape_count:
                 break
             # print(f"Processing image {image_id}...")
-            async with session.get(image_url) as response:
+            async with scrape_state.session.get(scrape_args.target) as response:
                 html = await response.text()
             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])
+            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(f"No image container found for {image_id}.")
-            if not use_low_quality:
+            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 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()
             tag_count = len(tags)
-            if tag_count < min_tags:
-                # print(f"Image {image_id} doesn't have enough tags({tag_count} < {min_tags}), skipped.")
+            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")
@@ -55,15 +65,19 @@ async def process_link(thread_pool, session, image_url, image_ids_to_ignore, wid
             image_path = os.path.join(IMAGE_DIR, image_id + image_ext)
             tags_path = os.path.join(IMAGE_DIR, image_id + ".txt")
             tags_text = ", ".join(libhtml.unescape(tag).replace("_", " ") for tag in tags)
-            async with session.get(image_download_url) as img_response:
+            async with scrape_state.session.get(image_download_url) as img_response:
                 img_data = await img_response.read()
             os.makedirs(IMAGE_DIR, exist_ok=True)
             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(thread_pool, image_path, tags_path, width, height, convert_to_avif):
-                image_ids_to_ignore.remove(image_id)
+            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
+                if scrape_state.scraped_image_count % 1000 == 0:
+                    print(f"Scraped {scrape_state.scraped_image_count}/{scrape_args.max_scrape_count} images.")
             return
         except Exception as e:
             error = e
@@ -71,18 +85,21 @@ async def process_link(thread_pool, session, image_url, image_ids_to_ignore, wid
                 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)
-    image_ids_to_ignore.remove(image_id)
+    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}")
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Scrape images from Gelbooru.")
-    parser.add_argument("-s", "--site", default="https://gelbooru.com", help="Domain to scrape from, defaults to https://gelbooru.com")
+    parser.add_argument("-s", "--site", default="https://gelbooru.com", help="Domain to scrape from, default to https://gelbooru.com")
     parser.add_argument("-W", "--width", type=int, help="Scale the width of the image to the specified value, must either provide both width and height or not provide both")
     parser.add_argument("-H", "--height", type=int, help="Scale the height of the image to the specified value, must either provide both width and height or not provide both")
     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("tags_to_search", nargs=argparse.REMAINDER, help="List of tags to search for, defaults to all")
+    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")
     args = parser.parse_args()
     if args.width is None or args.height is None:
         if args.width is not None or args.height is not None:
@@ -102,7 +119,10 @@ def parse_args():
             print("You need to pip install pillow-avif-plugin to use avif conversion!")
             sys.exit(1)
     if args.min_tags < 0:
-        print("Min tags must be greater than or equal to 0!")
+        print("Minimum tags must be greater than or equal to 0!")
+        sys.exit(1)
+    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"]
@@ -112,27 +132,33 @@ 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)
+    search_tags = utils.SearchTags(args.tags_to_search)
 
     os.makedirs(IMAGE_DIR, exist_ok=True)
-    image_ids_to_ignore = utils.get_existing_image_id_set(IMAGE_DIR)
+    existing_image_ids = utils.get_existing_image_id_set(IMAGE_DIR)
     utils.register_sigint_callback()
 
     async with aiohttp.ClientSession(cookies={"fringeBenefits": "yup"}, timeout=aiohttp.ClientTimeout(total=TIMEOUT)) as session:
-        thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count())
+        scrape_state = utils.ScrapeState(concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count()), session, existing_image_ids)
         tasks = []
         while True:
             try:
-                if utils.get_sigint_count() >= 1:
+                if utils.get_sigint_count() >= 1 or isinstance(args.max_scrape_count, int) and scrape_state.scraped_image_count >= args.max_scrape_count:
                     break
-                request_url = f"{args.site}/index.php?page=post&s=list&tags={search_tags}&pid={page_number}"
+                request_url = f"{args.site}/index.php?page=post&s=list&tags={search_tags.to_search_string()}&pid={page_number}"
                 print(f"Going to {request_url}")
-                async with session.get(request_url) as response:
+                async with scrape_state.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.")
+                notice_error = thumbnails_div.find("div", class_="notice error")
+                if notice_error and args.continuous_scraping:
+                    print("Reached restricted depth, adjusting search tags to continue scraping...")
+                    search_tags.update_bound(scrape_state)
+                    page_number = 0
+                    continue
                 image_urls = [a["href"] for a in thumbnails_div.find_all("a")]
                 image_url_count = len(image_urls)
                 if image_url_count == 0:
@@ -141,10 +167,10 @@ async def main():
                 print(f"Got {image_url_count} posts.")
                 page_number += image_url_count
                 for image_url in image_urls:
-                    if utils.get_sigint_count() >= 1:
+                    if utils.get_sigint_count() >= 1 or isinstance(args.max_scrape_count, int) and scrape_state.scraped_image_count >= args.max_scrape_count:
                         break
                     while len(tasks) >= MAX_TASKS:
-                        if utils.get_sigint_count() >= 1:
+                        if utils.get_sigint_count() >= 1 or isinstance(args.max_scrape_count, int) and scrape_state.scraped_image_count >= args.max_scrape_count:
                             break
                         await asyncio.sleep(0.1)
                         for i in range(len(tasks) - 1, -1, -1):
@@ -152,7 +178,7 @@ async def main():
                             if task.done():
                                 await task
                                 del tasks[i]
-                    tasks.append(asyncio.create_task(process_link(thread_pool, session, image_url, image_ids_to_ignore, args.width, args.height, args.avif, args.low_quality, args.min_tags)))
+                    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)))
             except Exception as e:
                 print(f"An error occurred: {e}\nPausing for 0.1 second before retrying...")
                 await asyncio.sleep(0.1)
@@ -167,8 +193,9 @@ async def main():
                 if task.done():
                     await task
                     del tasks[i]
-    if utils.get_sigint_count() >= 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!")
+    if utils.get_sigint_count() >= 1:
+        if utils.get_sigint_count() >= 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!")
         sys.exit(1)
 
 if __name__ == "__main__":

scrape_yan.py

@@ -12,12 +12,12 @@ from constants import *
 
 TIMEOUT = 30 # Local override.
 
-async def process_link(thread_pool, session, image_object, image_ids_to_ignore, width, height, convert_to_avif, use_low_quality, min_tags):
+async def process_link(thread_pool, session, image_object, existing_image_ids, width, height, convert_to_avif, use_low_quality, min_tags):
     image_id = str(image_object["id"])
-    if image_id in image_ids_to_ignore:
+    if image_id in existing_image_ids:
         # print(f"Image {image_id} already exists, skipped.")
         return
-    image_ids_to_ignore.add(image_id)
+    existing_image_ids.add(image_id)
     error = None
     for i in range(1, MAX_RETRY + 2): # 1 indexed.
         try:
@@ -29,9 +29,6 @@ async def process_link(thread_pool, session, image_object, image_ids_to_ignore,
             else:
                 image_url = image_object["sample_url"]
             image_ext = os.path.splitext(image_url)[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
@@ -56,7 +53,7 @@ async def process_link(thread_pool, session, image_object, image_ids_to_ignore,
             async with aiofiles.open(tags_path, "w", encoding="utf8") as f:
                 await f.write(tags_text)
             if not await utils.submit_validation(thread_pool, image_path, tags_path, width, height, convert_to_avif):
-                image_ids_to_ignore.remove(image_id)
+                existing_image_ids.remove(image_id)
             return
         except Exception as e:
             error = e
@@ -64,12 +61,12 @@ async def process_link(thread_pool, session, image_object, image_ids_to_ignore,
                 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)
-    image_ids_to_ignore.remove(image_id)
+    existing_image_ids.remove(image_id)
     print(f"All retry attempts failed, image {image_id} skipped. Final error {error.__class__.__name__}: {error}")
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Scrape images from yande.re.")
-    parser.add_argument("-s", "--site", default="https://yande.re", help="Domain to scrape from, defaults to https://yande.re")
+    parser.add_argument("-s", "--site", default="https://yande.re", help="Domain to scrape from, default to https://yande.re")
     parser.add_argument("-W", "--width", type=int, help="Scale the width of the image to the specified value, must either provide both width and height or not provide both")
     parser.add_argument("-H", "--height", type=int, help="Scale the height of the image to the specified value, must either provide both width and height or not provide both")
     parser.add_argument("-a", "--avif", action="store_true", help="If set, will convert the image into avif, need to have pillow-avif-plugin installed")
@@ -108,7 +105,7 @@ async def main():
     search_tags = "+".join(urllib.parse.quote(tag, safe="") for tag in args.tags_to_search)
 
     os.makedirs(IMAGE_DIR, exist_ok=True)
-    image_ids_to_ignore = utils.get_existing_image_id_set(IMAGE_DIR)
+    existing_image_ids = utils.get_existing_image_id_set(IMAGE_DIR)
     utils.register_sigint_callback()
 
     async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=TIMEOUT)) as session:
@@ -140,7 +137,7 @@ async def main():
                             if task.done():
                                 await task
                                 del tasks[i]
-                    tasks.append(asyncio.create_task(process_link(thread_pool, session, image_object, image_ids_to_ignore, args.width, args.height, args.avif, args.low_quality, args.min_tags)))
+                    tasks.append(asyncio.create_task(process_link(thread_pool, session, image_object, existing_image_ids, args.width, args.height, args.avif, args.low_quality, args.min_tags)))
             except Exception as e:
                 print(f"An error occurred: {e}\nPausing for 0.1 second before retrying...")
                 await asyncio.sleep(0.1)
@@ -155,8 +152,9 @@ async def main():
                 if task.done():
                     await task
                     del tasks[i]
-    if utils.get_sigint_count() >= 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!")
+    if utils.get_sigint_count() >= 1:
+        if utils.get_sigint_count() >= 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!")
         sys.exit(1)
 
 if __name__ == "__main__":

utils/__init__.py

@@ -1,3 +1,5 @@
 from .utils import *
+from .search_tags import *
+from .scrape_args import *
 from .scrape_state import *
 from .sigint_handler import *

utils/scrape_args.py

@@ -0,0 +1,12 @@
+from typing import Optional, Any
+from dataclasses import dataclass
+
+@dataclass
+class ScrapeArgs:
+    target: Any
+    width: Optional[int] = None
+    height: Optional[int] = None
+    convert_to_avif: bool = False
+    use_low_quality: bool = False
+    min_tags: int = 0
+    max_scrape_count: Optional[int] = None

utils/scrape_state.py

@@ -0,0 +1,13 @@
+from typing import Optional
+from aiohttp import ClientSession
+from dataclasses import dataclass, field
+from concurrent.futures import ThreadPoolExecutor
+
+@dataclass
+class ScrapeState:
+    thread_pool: ClientSession
+    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_score: Optional[int] = None

utils/search_tags.py

@@ -0,0 +1,137 @@
+import re
+import urllib
+from typing import Optional
+from dataclasses import dataclass
+
+COMPARE_FILTER_TAG_PATTERN = re.compile(r"^([a-z]+):([<>]?)(=?)(\S*)$", re.ASCII)
+WHITE_SPACE_PATTERN = re.compile(r"\s")
+
+@dataclass
+class SortTag:
+    sort_type: str = "id"
+    descending: bool = True
+
+    def __str__(self):
+        return "sort:" + self.sort_type + ":" + ("desc" if self.descending else "asc")
+
+    @classmethod
+    def validate_sort_type(cls, sort_type):
+        match sort_type:
+            case "id":
+                pass
+            case "score":
+                pass
+            case _:
+                raise NotImplementedError(f"Sort type \"{sort_type}\" is not implemented!")
+
+    @classmethod
+    def from_tag(cls, tag):
+        if not tag.startswith("sort:"):
+            return None
+        sort_type = None
+        descending = True
+        for i, sort_tag_part in enumerate(tag.split(":")):
+            match i:
+                case 0:
+                    pass
+                case 1:
+                    cls.validate_sort_type(sort_tag_part)
+                    sort_type = sort_tag_part
+                case 2:
+                    if sort_tag_part == "asc":
+                        descending = False
+                case _:
+                    raise ValueError(f"The sort tag \"{tag}\" you provided isn't valid!")
+        if i < 1:
+            raise ValueError(f"The sort tag \"{tag}\" you provided isn't valid!")
+        return cls(sort_type, descending)
+
+@dataclass
+class CompareFilterTag:
+    compare_type: str
+    less_than: bool
+    with_equal: bool
+    target: int
+
+    def __str__(self):
+        return self.compare_type + ":" + ("<" if self.less_than else ">") + ("=" if self.with_equal else "") + str(self.target)
+
+    @classmethod
+    def from_tag(cls, tag):
+        re_match = COMPARE_FILTER_TAG_PATTERN.search(tag)
+        if re_match is None:
+            return None
+        target = re_match.group(4)
+        if not target:
+            raise ValueError(f"The compare filter tag \"{tag}\" you provided isn't valid!")
+        less_than = re_match.group(2)
+        with_equal = re_match.group(3)
+        if not less_than:
+            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)
+
+class SearchTags:
+
+    def __init__(self, tags: list[str]):
+        self.general_tags: list[str] = []
+        self.sort_tag: SortTag = None
+        self.compare_filter_tags: list[CompareFilterTag] = []
+        self.sort_associated_compare_filter_tag: Optional[CompareFilterTag] = None
+        for tag in tags:
+            tag = tag.strip().lower()
+            if not tag:
+                continue
+            if WHITE_SPACE_PATTERN.search(tag):
+                raise ValueError(f"The tag \"{tag}\" contains white space(s), booru tags should use \"_\" instead of spaces!")
+            sort_tag = SortTag.from_tag(tag)
+            if sort_tag is not None:
+                if self.sort_tag is not None:
+                    raise ValueError("You can't provide more than 1 sort tag!")
+                self.sort_tag = sort_tag
+                continue
+            compare_filter_tag = CompareFilterTag.from_tag(tag)
+            if compare_filter_tag is not None:
+                self.compare_filter_tags.append(compare_filter_tag)
+                continue
+            self.general_tags.append(tag)
+        if self.sort_tag is None:
+            self.sort_tag = SortTag()
+        for i in range(len(self.compare_filter_tags) - 1, -1, -1):
+            compare_filter_tag = self.compare_filter_tags[i]
+            if compare_filter_tag.compare_type == self.sort_tag.sort_type and compare_filter_tag.less_than == self.sort_tag.descending:
+                if self.sort_associated_compare_filter_tag is not None:
+                    raise ValueError("You can't provide more than 1 sort associated compare filter tag!")
+                self.sort_associated_compare_filter_tag = compare_filter_tag
+                del self.compare_filter_tags[i]
+
+    def update_bound(self, scrape_state):
+        match self.sort_tag.sort_type:
+            case "id":
+                if scrape_state.last_reached_image_id is None:
+                    raise ValueError("Last reached image ID isn't set!")
+                self.sort_associated_compare_filter_tag = CompareFilterTag("id", self.sort_tag.descending, True, scrape_state.last_reached_image_id)
+            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)
+
+    def to_search_string(self):
+        tag_texts = [str(self.sort_tag)]
+        for compare_filter_tag in self.compare_filter_tags:
+            tag_texts.append(str(compare_filter_tag))
+        if self.sort_associated_compare_filter_tag is not None:
+            tag_texts.append(str(self.sort_associated_compare_filter_tag))
+        tag_texts += self.general_tags
+        return "+".join(urllib.parse.quote(tag_text, safe="") for tag_text in tag_texts)