Upload dump.py

dump.py

@@ -0,0 +1,167 @@
+import requests
+from bs4 import BeautifulSoup
+import json
+from concurrent.futures import ThreadPoolExecutor
+import argparse
+
+BASE = "https://cosppi.net"
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:108.0) Gecko/20100101 Firefox/108.0"
+RETRY_MAX = 3
+TIMEOUT = 20
+
+SROTS = ["all-rank", "china-rank", "new-add", "follower-rank"]
+
+def process_url(url):
+    if url.startswith("//"):
+        return f"https:{url}"
+    elif url.startswith("/"):
+        return f"{BASE}{url}"
+    else:
+        return url
+
+def get_user_urls(debug, sort, page):
+        found_urls = [] 
+        url = f"{BASE}/sort/{sort}/page/{page}"
+        print(f"Fetching {url}...")
+        for i in range(RETRY_MAX):
+            try:
+                response = requests.get(
+                    url,
+                    headers={"User-Agent": USER_AGENT},
+                    timeout=TIMEOUT,
+                )
+                response.raise_for_status()
+                break
+            except requests.exceptions.RequestException as e:
+                print(f"Error: {e}")
+                if i < RETRY_MAX - 1:
+                    print("Retrying after 3 seconds...")
+                else:
+                    print("Max retries reached.")
+        
+        if response.status_code == 404 or (debug and page >= 2):
+            print(f"Page {page} not found!")
+            return None
+        else:
+            print(f"Fetched page {page}")
+        soup = BeautifulSoup(response.text, "html.parser")
+        main_section = soup.find("main")
+        users = main_section.find_all("a", {"class": "sort_prof_link"})
+        if not users:
+            return None
+        for user in users:
+            raw_url = user.get("href")
+            processed_url = process_url(raw_url)
+            found_urls.append(processed_url)
+            print(f"User URL found: {processed_url}")
+        return found_urls
+
+def get_all_user_urls(debug, sort, thread_count):
+    pages = range(1, 50)
+    
+    with ThreadPoolExecutor(max_workers=thread_count) as executor:
+        user_urls = executor.map(get_user_urls, [debug] * len(pages), [sort] * len(pages), pages)
+
+    # remove None and flatten list
+    user_urls = [url for sublist in user_urls if sublist for url in sublist]
+
+    print(f"\nTotal number of user pages: {len(user_urls)}\n")
+    return user_urls
+
+def get_user_images(user_url):
+    page = 1
+
+    images = []
+
+    while True:
+        response = requests.get(
+            f"{user_url}/page/{page}",
+            headers={"User-Agent": USER_AGENT},
+        )
+        if response.status_code == 404:
+            print(f"User {user_url} not found!")
+            break
+        else:
+            print(f"Fetching user images {user_url}...")
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        img_wrapper_outer = soup.find("div", {"class": "img_wrapper_outer"})
+        image_wrappers = img_wrapper_outer.find_all("div", {"class": "img_wrapper"})
+
+        if not image_wrappers:
+            print(f"User {user_url} has no images!")
+            break
+
+        print(f"Found {len(image_wrappers)} images on page {page}...")
+
+        for image_wrapper in image_wrappers:
+            url = image_wrapper.find("img").get("data-src")
+            # remove last ":small" or ":large"
+            url = url.rsplit(":", 1)[0]
+            span_tags = image_wrapper.find("div", {"class": "img_num"}).find_all("span")
+            [likes, retweets] = [int(span_tag.text) for span_tag in span_tags]
+
+            image_item = {
+                "url": url,
+                "likes": likes,
+                "retweets": retweets,
+            }
+            images.append(image_item)
+
+        page += 1
+
+    print(f"Images found in article {user_url}: {len(images)}")
+
+    username = user_url.split("/")[-1]
+
+    return {
+        "username": username,
+        "images": images,
+    }
+
+def get_image_urls(user_urls, thread_count):
+
+    with ThreadPoolExecutor(max_workers=thread_count) as executor:
+        results = executor.map(get_user_images, user_urls)
+
+    return [result for result in results]
+
+def main(debug, thread_count, output_path, sort):
+    user_urls = get_all_user_urls(debug, sort, thread_count)
+
+    print(f"\nFetching images from {len(user_urls)} user pages...")
+    print(user_urls)
+
+    users_and_images = get_image_urls(user_urls, thread_count)
+    
+    print(f"\nTotal number of users: {len(users_and_images)}")
+    num_images = 0
+    for user in users_and_images:
+        num_images += len(user["images"])
+    print(f"Total number of images: {num_images}")
+
+    # preview
+    print("\nPreview:")
+    # 1~3
+    for user in users_and_images[:3]:
+        print(f"Username: {user['username']}")
+        print(f"Number of images: {len(user['images'])}")
+        print(f"First image: {user['images'][0]['url']}")
+        print(f"Last image: {user['images'][-1]['url']}")
+        print()
+
+    print(f"\nWriting to {output_path}...")
+    with open(output_path, "w", encoding="utf-8") as output_file:
+        json.dump(users_and_images, output_file, indent=4)
+    print("Done!")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode (only fetches up to page 2)")
+    parser.add_argument("--threads", type=int, default=5, help="Number of threads to use for parallel processing")
+    parser.add_argument("--output", type=str, default="output.json", help="Output file name for JSON data")
+    parser.add_argument("--sort", type=str, default="all-rank", help="Sort type")
+    args = parser.parse_args()
+
+    main(args.debug, args.threads, args.output, args.sort)
+