Fixed requests become slower over time by refreshing session.

scrape_gel.py

@@ -1,6 +1,7 @@
 import os
 import re
 import sys
+import time
 import utils
 import random
 import urllib
@@ -28,8 +29,10 @@ async def process_link(scrape_args, scrape_state):
             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}...")
+            query_start_time = time.time()
             async with scrape_state.session.get(scrape_args.target) as response:
                 html = await response.text()
+            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:
@@ -65,9 +68,10 @@ async def process_link(scrape_args, scrape_state):
             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)
+            download_start_time = time.time()
             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)
+            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:
@@ -76,8 +80,20 @@ async def process_link(scrape_args, scrape_state):
                 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.")
+                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]
             return
         except Exception as e:
             error = e
@@ -138,61 +154,78 @@ async def main():
     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:
-        scrape_state = utils.ScrapeState(concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count()), session, existing_image_ids)
-        tasks = []
-        while True:
-            try:
+    session_args = [TIMEOUT, {"fringeBenefits": "yup"}]
+    scrape_state = utils.ScrapeState(concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count()), utils.get_session(*session_args), existing_image_ids)
+    session_refresh_counter = 0
+    tasks = []
+    while True:
+        try:
+            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.to_search_string()}&pid={page_number}"
+            print(f"Going to {request_url}")
+            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:
+                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 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.to_search_string()}&pid={page_number}"
-                print(f"Going to {request_url}")
-                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:
-                    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:
+                while len(tasks) >= MAX_TASKS:
                     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 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):
-                            task = tasks[i]
-                            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.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)
-        if utils.get_sigint_count() >= 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 utils.get_sigint_count() <= 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]
+                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
+            if session_refresh_counter % 50 == 0:
+                print("Refreshing session...")
+                while tasks and utils.get_sigint_count() < 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]
+                if utils.get_sigint_count() < 1:
+                    await scrape_state.session.close()
+                    scrape_state.session = utils.get_session(*session_args)
+        except Exception as e:
+            print(f"An error occurred: {e}\nPausing for 0.1 second before retrying...")
             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]
+    if utils.get_sigint_count() >= 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 utils.get_sigint_count() <= 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]
+    await scrape_state.session.close()
     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!")

scrape_yan.py

@@ -47,7 +47,6 @@ async def process_link(thread_pool, session, image_object, existing_image_ids, w
             tags_text = ", ".join(tag.replace("_", " ").replace("nekomimi", "cat girl") for tag in tags)
             async with session.get(image_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:
@@ -108,7 +107,7 @@ async def main():
     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:
+    async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=TIMEOUT), connector=aiohttp.TCPConnector(limit=0, ttl_dns_cache=600)) as session:
         thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count())
         tasks = []
         while True:

utils/scrape_state.py

@@ -11,3 +11,5 @@ class ScrapeState:
     scraped_image_count: int = 0
     last_reached_image_id: Optional[int] = 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/utils.py

@@ -1,5 +1,6 @@
 import os
 import asyncio
+import aiohttp
 from PIL import Image
 
 def validate_image(image_path, tags_path, width=None, height=None, convert_to_avif=False):
@@ -63,3 +64,9 @@ def get_image_id_image_tags_path_tuple_dict(image_dir):
 
 def get_existing_image_id_set(image_dir):
     return set(get_image_id_image_tags_path_tuple_dict(image_dir))
+
+def get_session(timeout=None, cookies=None):
+    kwargs = {"connector": aiohttp.TCPConnector(limit=0, ttl_dns_cache=600), "cookies": cookies}
+    if timeout is not None:
+        kwargs["timeout"] = aiohttp.ClientTimeout(total=timeout)
+    return aiohttp.ClientSession(**kwargs)