jh

API/app.py

@@ -7,10 +7,13 @@ import tempfile
 import zipfile
 import os
 from pydantic import BaseModel
-from typing import List, Dict
+from typing import List, Dict, Optional
 
 
 img_base = 'https://i.pximg.net/img-original/img/'
+COMMENTS_ROOTS_URL = "https://www.pixiv.net/ajax/illusts/comments/roots"
+COMMENTS_REPLIES_URL = "https://www.pixiv.net/ajax/illusts/comments/replies"
+COMMENTS_LIMIT = 30
 
 class pixifModel(BaseModel):
     post_ids: List[int]
@@ -22,6 +25,11 @@ class PixifDownloadModel(BaseModel):
 class PixifZipModel(BaseModel):
     d: Dict[str, str]
 
+class PixifCommentsModel(BaseModel):
+    post_ids: List[int]
+    phpsessid: str
+    limit: int = COMMENTS_LIMIT
+
 headers = {
     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0",
     'referer': 'https://www.pixiv.net/',
@@ -29,8 +37,13 @@ headers = {
 
 app = FastAPI()
 
-async def fetch_page(session, url):
-    async with session.get(url) as response:
+async def fetch_page(session, url, params=None, extra_headers=None, semaphore: Optional[asyncio.Semaphore] = None):
+    if semaphore:
+        async with semaphore:
+            async with session.get(url, params=params, headers=extra_headers) as response:
+                data = await response.json()
+                return data
+    async with session.get(url, params=params, headers=extra_headers) as response:
         data = await response.json()
         return data
 
@@ -95,6 +108,91 @@ def parse_png_metadata(data):
         index += chunk_len + 4
     return None
 
+def format_comment_text(comment):
+    text = comment.get("comment") or ""
+    if not text and comment.get("stampId"):
+        text = f"[stamp:{comment['stampId']}]"
+    return text
+
+async def fetch_comment_replies(comment_id, post_id, session, semaphore):
+    replies = []
+    page = 1
+    referer = {"Referer": f"https://www.pixiv.net/artworks/{post_id}"}
+
+    while True:
+        params = {"comment_id": comment_id, "page": page, "lang": "en"}
+        payload = await fetch_page(
+            session,
+            COMMENTS_REPLIES_URL,
+            params=params,
+            extra_headers=referer,
+            semaphore=semaphore,
+        )
+
+        if payload.get("error"):
+            message = payload.get("message") or "Unknown error"
+            raise RuntimeError(f"Pixiv error for reply {comment_id}: {message}")
+
+        body = payload.get("body") or {}
+        comments = body.get("comments") or []
+
+        for reply in comments:
+            replies.append(
+                {
+                    "name": reply.get("userName") or "",
+                    "Comment": format_comment_text(reply),
+                }
+            )
+
+        if not body.get("hasNext"):
+            break
+        page += 1
+
+    return replies
+
+async def fetch_post_comments(post_id, session, limit, semaphore):
+    offset = 0
+    results = []
+    referer = {"Referer": f"https://www.pixiv.net/artworks/{post_id}"}
+
+    while True:
+        params = {"illust_id": post_id, "offset": offset, "limit": limit}
+        payload = await fetch_page(
+            session,
+            COMMENTS_ROOTS_URL,
+            params=params,
+            extra_headers=referer,
+            semaphore=semaphore,
+        )
+
+        if payload.get("error"):
+            message = payload.get("message") or "Unknown error"
+            raise RuntimeError(f"Pixiv error for {post_id}: {message}")
+
+        body = payload.get("body") or {}
+        comments = body.get("comments") or []
+
+        for comment in comments:
+            replies = []
+            if comment.get("hasReplies"):
+                try:
+                    replies = await fetch_comment_replies(comment.get("id"), post_id, session, semaphore)
+                except Exception:
+                    replies = []
+            results.append(
+                {
+                    "name": comment.get("userName") or "",
+                    "Comment": format_comment_text(comment),
+                    "Replies": replies,
+                }
+            )
+
+        if not body.get("hasNext"):
+            break
+        offset += limit
+
+    return str(post_id), results
+
 async def process_post(post_id, session, semaphore):
     async with semaphore:
         try:
@@ -222,6 +320,31 @@ async def pixif_zip(items: PixifZipModel, background_tasks: BackgroundTasks):
     filename = f"pixif_{base26_time()}.zip"
     return FileResponse(tmp_path, media_type="application/zip", filename=filename)
 
+@app.post("/comments")
+async def comments(items: PixifCommentsModel):
+    if not items.post_ids:
+        return {"comments": {}}
+
+    cookies = build_cookies(items.phpsessid)
+    semaphore = asyncio.Semaphore(10)
+
+    async with aiohttp.ClientSession(cookies=cookies, headers=headers) as session:
+        tasks = [
+            fetch_post_comments(post_id, session, items.limit, semaphore)
+            for post_id in items.post_ids
+        ]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    comments_by_post = {}
+    for post_id, result in zip(items.post_ids, results):
+        if isinstance(result, Exception):
+            comments_by_post[str(post_id)] = []
+        else:
+            key, comments = result
+            comments_by_post[str(key)] = comments
+
+    return {"comments": comments_by_post}
+
 @app.get("/")
 async def read_root():
     return {"message": "Hello, World!"}

Client/comments.py

@@ -1,16 +1,10 @@
 import os
 import json
 import requests
-from tqdm import tqdm
 
 
-COMMENTS_URL = "https://www.pixiv.net/ajax/illusts/comments/roots"
 COMMENTS_LIMIT = 30
-
-HEADERS = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0",
-    "Referer": "https://www.pixiv.net/",
-}
+DEFAULT_ENDPOINT = "http://127.0.0.1:7860"
 
 
 def read_dotenv_value(path, key):
@@ -39,47 +33,26 @@ def get_phpsessid():
     raise RuntimeError("PHPSESSID is not set in the environment or .env")
 
 
-def build_session(phpsessid):
-    session = requests.Session()
-    session.cookies.update({"PHPSESSID": phpsessid})
-    session.headers.update(HEADERS)
-    return session
-
-
-def fetch_comments(post_id, session, limit=COMMENTS_LIMIT):
-    offset = 0
-    results = []
-
-    while True:
-        params = {"illust_id": post_id, "offset": offset, "limit": limit}
-        headers = {"Referer": f"https://www.pixiv.net/artworks/{post_id}"}
-        response = session.get(COMMENTS_URL, params=params, headers=headers, timeout=30)
-        response.raise_for_status()
-        payload = response.json()
-
-        if payload.get("error"):
-            message = payload.get("message") or "Unknown error"
-            raise RuntimeError(f"Pixiv error for {post_id}: {message}")
-
-        body = payload.get("body") or {}
-        comments = body.get("comments") or []
-
-        for comment in comments:
-            text = comment.get("comment") or ""
-            if not text and comment.get("stampId"):
-                text = f"[stamp:{comment['stampId']}]"
-            results.append(
-                {
-                    "name": comment.get("userName") or "",
-                    "Comment": text,
-                }
-            )
+def get_endpoint():
+    endpoint = os.getenv("PIXIF_ENDPOINT")
+    if endpoint:
+        return endpoint.rstrip("/")
+    env_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".env"))
+    endpoint = read_dotenv_value(env_path, "PIXIF_ENDPOINT")
+    if endpoint:
+        return endpoint.rstrip("/")
+    return DEFAULT_ENDPOINT
 
-        if not body.get("hasNext"):
-            break
-        offset += limit
 
-    return results
+def fetch_comments(post_ids, phpsessid, endpoint, limit=COMMENTS_LIMIT):
+    payload = {"post_ids": post_ids, "phpsessid": phpsessid, "limit": limit}
+    response = requests.post(f"{endpoint}/comments", json=payload, timeout=300)
+    response.raise_for_status()
+    data = response.json()
+    comments = data.get("comments", data)
+    if not isinstance(comments, dict):
+        raise RuntimeError("Unexpected response from comments endpoint.")
+    return comments
 
 
 def parse_indexes(inputs):
@@ -109,25 +82,26 @@ def main():
     indexes = parse_indexes(inputs)
 
     phpsessid = get_phpsessid()
-    session = build_session(phpsessid)
+    endpoint = get_endpoint()
 
     for index in indexes:
         if index < 0 or index >= len(valid):
             continue
         group_name = valid[index].rsplit(".", 1)[0]
         with open(valid[index], "r") as f:
-            post_ids = f.read().split()
+            raw_ids = f.read().split()
 
+        post_ids = [int(post_id) for post_id in raw_ids if post_id.isdigit()]
         if not post_ids:
             continue
 
-        comments_by_post = {}
-        for post_id in tqdm(post_ids, desc=f"Fetching {group_name}"):
-            try:
-                comments_by_post[str(post_id)] = fetch_comments(post_id, session)
-            except Exception as exc:
-                print(f"Failed to fetch comments for {post_id}: {exc}")
-                comments_by_post[str(post_id)] = []
+        try:
+            fetched = fetch_comments(post_ids, phpsessid, endpoint)
+        except Exception as exc:
+            print(f"Failed to fetch comments for {group_name}: {exc}")
+            fetched = {}
+
+        comments_by_post = {str(post_id): fetched.get(str(post_id), []) for post_id in post_ids}
 
         output_path = os.path.join("comments", f"{group_name}.json")
         with open(output_path, "w", encoding="utf-8") as f: