commit
9c5fef1a4d
412 files changed
+94582
No files matched your search
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"name": "长佩文学",
|
||||
"version": "1.0.0",
|
||||
"domain": "www.gongzicp.com",
|
||||
"author": "Sakura Downloader",
|
||||
"description": "长佩文学(gongzicp.com)小说搜索、目录解析、章节抓取与 TXT 导出。",
|
||||
"requires_auth": true,
|
||||
"tags": ["novel", "gongzicp", "changpei", "bookshelf"],
|
||||
"min_platform_version": "1.0.0",
|
||||
"dependencies": []
|
||||
}
|
||||
@@ -0,0 +1,514 @@
|
||||
"""
|
||||
Changpei (长佩文学 / gongzicp.com) novel plugin.
|
||||
|
||||
Uses the public webapi endpoints on https://www.gongzicp.com/webapi/.
|
||||
Chapter bodies are AES-CBC encrypted; decryption matches the site's CryptoJS helper.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from html import unescape
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from urllib.parse import urljoin, urlparse
|
||||
|
||||
import requests
|
||||
|
||||
try:
|
||||
from cryptography.hazmat.primitives import padding as crypto_padding
|
||||
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
|
||||
|
||||
CRYPTOGRAPHY_AVAILABLE = True
|
||||
except Exception:
|
||||
crypto_padding = None
|
||||
Cipher = None
|
||||
algorithms = None
|
||||
modes = None
|
||||
CRYPTOGRAPHY_AVAILABLE = False
|
||||
|
||||
from pixiv_app.core.downloader import sanitize_filename, save_text_file
|
||||
from pixiv_app.core.plugin.base import BasePlugin, PluginParseError, Resource
|
||||
|
||||
BASE_URL = "https://www.gongzicp.com"
|
||||
WEBAPI_BASE = f"{BASE_URL}/webapi"
|
||||
USER_AGENT = (
|
||||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
|
||||
"(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
|
||||
)
|
||||
|
||||
_NOVEL_PATH_RE = re.compile(r"/novel-(?P<nid>\d+)\.html", re.I)
|
||||
_READ_PATH_RE = re.compile(r"/read-(?P<nid>\d+)-(?P<cid>\d+)\.html", re.I)
|
||||
_SINGLE_READ_RE = re.compile(r"/read-(?P<cid>\d+)\.html", re.I)
|
||||
|
||||
|
||||
@dataclass
|
||||
class BookCandidate:
|
||||
title: str
|
||||
url: str
|
||||
author: str = ""
|
||||
latest_chapter: str = ""
|
||||
|
||||
|
||||
@dataclass
|
||||
class TargetIds:
|
||||
novel_id: str = ""
|
||||
chapter_id: str = ""
|
||||
|
||||
|
||||
def _js_to_string(value: int, base: int) -> str:
|
||||
digits = "0123456789abcdefghijklmnopqrstuvwxyz"
|
||||
chars: list[str] = []
|
||||
while value:
|
||||
chars.append(digits[value % base])
|
||||
value //= base
|
||||
return "".join(reversed(chars)) or "0"
|
||||
|
||||
|
||||
def _clean_html_text(raw: str) -> str:
|
||||
text = re.sub(r"<br\s*/?>", "\n", raw, flags=re.I)
|
||||
text = re.sub(r"</p\s*>", "\n", text, flags=re.I)
|
||||
text = re.sub(r"<[^>]+>", "", text)
|
||||
text = unescape(text)
|
||||
text = text.replace("\r", "")
|
||||
lines = [line.strip() for line in text.splitlines()]
|
||||
return "\n".join(line for line in lines if line)
|
||||
|
||||
|
||||
def _normalize_space(value: str) -> str:
|
||||
return re.sub(r"\s+", " ", _clean_html_text(value)).strip()
|
||||
|
||||
|
||||
class _ChapterDecryptor:
|
||||
"""AES-CBC decryptor matching index.eef719ce.js class XE."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
if not CRYPTOGRAPHY_AVAILABLE:
|
||||
raise PluginParseError("缺少 cryptography 依赖,无法解密长佩章节正文。")
|
||||
suffix = _js_to_string(int("165455", 14), 32)
|
||||
key_seed = "iGzsYn" + suffix
|
||||
iv_str = f"$h$b3!{key_seed}"
|
||||
decoded = base64.b64decode("dTBMUnJidSRFbg==").decode("utf-8")
|
||||
key_str = decoded + _js_to_string(int("4d5a6c8", 14), 36) + "A"
|
||||
self._key = key_str.encode("utf-8")
|
||||
self._iv = iv_str.encode("utf-8")
|
||||
|
||||
def decrypt(self, encrypted_b64: str) -> str:
|
||||
if not encrypted_b64:
|
||||
return ""
|
||||
raw = base64.b64decode(encrypted_b64)
|
||||
cipher = Cipher(algorithms.AES(self._key), modes.CBC(self._iv))
|
||||
decryptor = cipher.decryptor()
|
||||
padded = decryptor.update(raw) + decryptor.finalize()
|
||||
unpadder = crypto_padding.PKCS7(128).unpadder()
|
||||
plain = unpadder.update(padded) + unpadder.finalize()
|
||||
return plain.decode("utf-8")
|
||||
|
||||
|
||||
class ChangpeiPlugin(BasePlugin):
|
||||
name = "长佩文学"
|
||||
domain = "www.gongzicp.com"
|
||||
version = "1.0.0"
|
||||
|
||||
def __init__(self, cookie: str = "") -> None:
|
||||
self.cookie = cookie
|
||||
self.session = requests.Session()
|
||||
self.session.headers.update(self.get_headers())
|
||||
self._chapter_decryptor: _ChapterDecryptor | None = None
|
||||
|
||||
def set_auth(self, cookie: str) -> None:
|
||||
"""设置登录 Cookie,用于访问需订阅/登录的章节。"""
|
||||
self.cookie = cookie or ""
|
||||
self.session.headers.update(self.get_headers())
|
||||
|
||||
def validate(self) -> bool:
|
||||
return CRYPTOGRAPHY_AVAILABLE
|
||||
|
||||
def can_handle(self, url: str) -> bool:
|
||||
lowered = url.strip().lower()
|
||||
if any(host in lowered for host in ("gongzicp.com", "gongzicp.cn")):
|
||||
return True
|
||||
if lowered.isdigit():
|
||||
return True
|
||||
return False
|
||||
|
||||
def get_headers(self) -> dict[str, str]:
|
||||
headers = {
|
||||
"User-Agent": USER_AGENT,
|
||||
"Accept": "application/json, text/plain, */*",
|
||||
"Accept-Language": "zh-CN,zh;q=0.9",
|
||||
"Referer": BASE_URL + "/",
|
||||
}
|
||||
if self.cookie:
|
||||
headers["Cookie"] = self.cookie
|
||||
return headers
|
||||
|
||||
def resolve_target(self, target: str, *, limit: int = 20) -> dict[str, Any]:
|
||||
raw = target.strip()
|
||||
if not raw:
|
||||
raise PluginParseError("请输入书名、作者、书籍链接或章节链接。")
|
||||
|
||||
normalized = self._normalize_target(raw)
|
||||
if normalized:
|
||||
ids = self._extract_ids_from_url(normalized)
|
||||
if ids.novel_id and ids.chapter_id:
|
||||
chapter = self._chapter_resource_from_ids(ids.novel_id, ids.chapter_id, source_url=normalized)
|
||||
return {
|
||||
"mode": "chapters",
|
||||
"book_title": str(chapter.metadata.get("book_title") or ""),
|
||||
"resources": [chapter],
|
||||
}
|
||||
if ids.novel_id:
|
||||
return self._resolve_novel_id(ids.novel_id)
|
||||
if ids.chapter_id and not ids.novel_id:
|
||||
raise PluginParseError("章节链接缺少书籍 ID,请使用 read-{书籍ID}-{章节ID}.html 格式。")
|
||||
|
||||
if raw.isdigit():
|
||||
return self._resolve_novel_id(raw)
|
||||
|
||||
books = self._search_books(raw, limit=limit)
|
||||
if not books:
|
||||
raise PluginParseError(f"没有搜索到与“{raw}”相关的书籍。")
|
||||
return {
|
||||
"mode": "books",
|
||||
"title": f"搜索结果:{raw}",
|
||||
"books": [candidate.__dict__ for candidate in books],
|
||||
}
|
||||
|
||||
def parse(self, url: str) -> list[Resource]:
|
||||
outcome = self.resolve_target(url, limit=20)
|
||||
if outcome.get("mode") == "chapters":
|
||||
return list(outcome.get("resources") or [])
|
||||
books = list(outcome.get("books") or [])
|
||||
if not books:
|
||||
raise PluginParseError("未解析到可下载内容。")
|
||||
selected = self.resolve_target(str(books[0].get("url") or ""), limit=20)
|
||||
resources = list(selected.get("resources") or [])
|
||||
if not resources:
|
||||
raise PluginParseError("选中的书籍没有章节内容。")
|
||||
return resources
|
||||
|
||||
def download(self, resource: Resource, save_path: Path) -> list[Path]:
|
||||
if str(resource.metadata.get("kind") or "") != "novel_chapter":
|
||||
raise PluginParseError("不支持的长佩资源类型。")
|
||||
|
||||
content = str(resource.metadata.get("content") or "")
|
||||
if not content.strip():
|
||||
nid = str(resource.metadata.get("novel_id") or resource.metadata.get("book_id") or "")
|
||||
cid = str(resource.metadata.get("chapter_id") or "")
|
||||
if nid and cid:
|
||||
preserved_title = str(resource.metadata.get("book_title") or "")
|
||||
preserved_author = str(resource.author or resource.metadata.get("author") or "")
|
||||
chapter_data = self._chapter_data_from_api(nid, cid)
|
||||
content = str(chapter_data.get("content") or "")
|
||||
resource.metadata.update(chapter_data)
|
||||
if preserved_title and not str(resource.metadata.get("book_title") or "").strip():
|
||||
resource.metadata["book_title"] = preserved_title
|
||||
if preserved_author and not str(resource.author or "").strip():
|
||||
resource.author = preserved_author
|
||||
|
||||
book_title = str(resource.metadata.get("book_title") or "未命名小说")
|
||||
chapter_title = str(resource.metadata.get("chapter_title") or resource.title or "未命名章节")
|
||||
chapter_order = int(resource.metadata.get("chapter_order") or 0)
|
||||
|
||||
folder = save_path / "novels" / sanitize_filename(book_title, "changpei_book")
|
||||
filename = (
|
||||
f"{chapter_order:04d}_{sanitize_filename(chapter_title, 'chapter')}.txt"
|
||||
if chapter_order
|
||||
else f"{sanitize_filename(chapter_title, 'chapter')}.txt"
|
||||
)
|
||||
final_path = folder / filename
|
||||
text = "\n".join(
|
||||
[
|
||||
f"书名: {book_title}",
|
||||
f"章节: {chapter_title}",
|
||||
f"作者: {resource.author or '未知'}",
|
||||
f"链接: {resource.url}",
|
||||
"",
|
||||
content.strip(),
|
||||
]
|
||||
).strip()
|
||||
save_text_file(final_path, text)
|
||||
resource.metadata["word_count"] = len(content)
|
||||
return [final_path]
|
||||
|
||||
def _get_decryptor(self) -> _ChapterDecryptor:
|
||||
if self._chapter_decryptor is None:
|
||||
self._chapter_decryptor = _ChapterDecryptor()
|
||||
return self._chapter_decryptor
|
||||
|
||||
def _normalize_target(self, target: str) -> str:
|
||||
value = target.strip()
|
||||
lowered = value.lower()
|
||||
if lowered.startswith(("http://", "https://", "//")):
|
||||
if value.startswith("//"):
|
||||
return "https:" + value
|
||||
return value
|
||||
if lowered.startswith(("www.gongzicp.com", "gongzicp.com")):
|
||||
return "https://" + value.lstrip("/")
|
||||
if _NOVEL_PATH_RE.search(value) or _READ_PATH_RE.search(value) or _SINGLE_READ_RE.search(value):
|
||||
return urljoin(BASE_URL, value.lstrip("/"))
|
||||
return ""
|
||||
|
||||
def _extract_ids_from_url(self, url: str) -> TargetIds:
|
||||
parsed = urlparse(url)
|
||||
path = parsed.path or ""
|
||||
match = _READ_PATH_RE.search(path)
|
||||
if match:
|
||||
return TargetIds(novel_id=match.group("nid"), chapter_id=match.group("cid"))
|
||||
match = _NOVEL_PATH_RE.search(path)
|
||||
if match:
|
||||
return TargetIds(novel_id=match.group("nid"))
|
||||
match = _SINGLE_READ_RE.search(path)
|
||||
if match:
|
||||
return TargetIds(chapter_id=match.group("cid"))
|
||||
return TargetIds()
|
||||
|
||||
def _webapi_get(self, path: str, *, params: dict[str, Any] | None = None, referer: str = "") -> dict[str, Any]:
|
||||
headers = dict(self.get_headers())
|
||||
if referer:
|
||||
headers["Referer"] = referer
|
||||
response = self.session.get(
|
||||
f"{WEBAPI_BASE}{path}",
|
||||
params=params or {},
|
||||
headers=headers,
|
||||
timeout=30,
|
||||
)
|
||||
response.raise_for_status()
|
||||
payload = response.json()
|
||||
code = payload.get("code")
|
||||
if code not in (200, "200"):
|
||||
message = str(payload.get("msg") or "请求失败")
|
||||
raise PluginParseError(f"长佩接口错误:{message}")
|
||||
data = payload.get("data")
|
||||
if isinstance(data, dict):
|
||||
return data
|
||||
if data is None:
|
||||
return {}
|
||||
return {"value": data}
|
||||
|
||||
def _novel_url(self, novel_id: str) -> str:
|
||||
return f"{BASE_URL}/novel-{novel_id}.html"
|
||||
|
||||
def _chapter_url(self, novel_id: str, chapter_id: str) -> str:
|
||||
return f"{BASE_URL}/read-{novel_id}-{chapter_id}.html"
|
||||
|
||||
def _search_books(self, keyword: str, *, limit: int) -> list[BookCandidate]:
|
||||
page = 1
|
||||
books: list[BookCandidate] = []
|
||||
while len(books) < limit:
|
||||
data = self._webapi_get(
|
||||
"/search/novels",
|
||||
params={"k": keyword, "page": page},
|
||||
referer=f"{BASE_URL}/novel/searchNovel",
|
||||
)
|
||||
items = list(data.get("list") or [])
|
||||
if not items:
|
||||
break
|
||||
for item in items:
|
||||
novel_id = str(item.get("novel_id") or "").strip()
|
||||
title = _normalize_space(str(item.get("novel_name") or ""))
|
||||
if not novel_id or not title:
|
||||
continue
|
||||
author = _normalize_space(str(item.get("novel_author") or item.get("author_nickname") or ""))
|
||||
books.append(
|
||||
BookCandidate(
|
||||
title=title,
|
||||
url=self._novel_url(novel_id),
|
||||
author=author,
|
||||
latest_chapter=_normalize_space(str(item.get("novel_uptime") or "")),
|
||||
)
|
||||
)
|
||||
if len(books) >= limit:
|
||||
break
|
||||
if len(items) < 10:
|
||||
break
|
||||
page += 1
|
||||
return books
|
||||
|
||||
def _novel_info(self, novel_id: str) -> dict[str, Any]:
|
||||
referer = self._novel_url(novel_id)
|
||||
return self._webapi_get("/novel/novelInfo", params={"id": novel_id}, referer=referer)
|
||||
|
||||
def _chapter_list(self, novel_id: str) -> list[dict[str, Any]]:
|
||||
referer = self._novel_url(novel_id)
|
||||
data = self._webapi_get("/novel/chapterGetList", params={"nid": novel_id}, referer=referer)
|
||||
return list(data.get("list") or [])
|
||||
|
||||
def _decrypt_chapter_content(self, encrypted: str) -> str:
|
||||
try:
|
||||
return self._get_decryptor().decrypt(encrypted)
|
||||
except Exception:
|
||||
return ""
|
||||
|
||||
def _chapter_data_from_api(self, novel_id: str, chapter_id: str) -> dict[str, Any]:
|
||||
referer = self._chapter_url(novel_id, chapter_id)
|
||||
payload = self._webapi_get(
|
||||
"/novel/chapterGetInfo",
|
||||
params={"nid": novel_id, "cid": chapter_id},
|
||||
referer=referer,
|
||||
)
|
||||
chapter_info = dict(payload.get("chapterInfo") or {})
|
||||
novel_info = dict(payload.get("novelInfo") or {})
|
||||
|
||||
locked = bool(chapter_info.get("lock")) or bool(chapter_info.get("chapter_ispay"))
|
||||
status = int(chapter_info.get("status") or 0)
|
||||
encrypted = str(chapter_info.get("content") or "")
|
||||
content = ""
|
||||
if not locked and status == 1 and encrypted:
|
||||
content = self._decrypt_chapter_content(encrypted)
|
||||
|
||||
chapter_title = _normalize_space(str(chapter_info.get("name") or f"章节 {chapter_id}"))
|
||||
book_title = _normalize_space(str(novel_info.get("name") or novel_info.get("novel_name") or ""))
|
||||
author = _normalize_space(str(novel_info.get("author") or novel_info.get("author_nickname") or ""))
|
||||
order = int(chapter_info.get("order") or 0)
|
||||
source_id = f"{novel_id}:{chapter_id}"
|
||||
|
||||
if locked:
|
||||
content = "[章节需订阅或已锁定,无法抓取正文]"
|
||||
|
||||
return {
|
||||
"source_id": source_id,
|
||||
"novel_id": novel_id,
|
||||
"book_id": novel_id,
|
||||
"book_title": book_title,
|
||||
"chapter_id": chapter_id,
|
||||
"chapter_title": chapter_title,
|
||||
"chapter_order": order,
|
||||
"author": author,
|
||||
"content": content,
|
||||
"word_count": len(content),
|
||||
"locked": locked,
|
||||
"description": _clean_html_text(str(novel_info.get("novel_info") or novel_info.get("novel_desc") or "")),
|
||||
}
|
||||
|
||||
def _flatten_chapter_items(self, items: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
result: list[dict[str, Any]] = []
|
||||
|
||||
for item in items:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
|
||||
if str(item.get("type") or "") == "item":
|
||||
result.append(item)
|
||||
|
||||
for key in ("children", "list", "chapterList", "chapters"):
|
||||
child_items = item.get(key)
|
||||
if isinstance(child_items, list):
|
||||
result.extend(self._flatten_chapter_items(child_items))
|
||||
|
||||
return result
|
||||
|
||||
def _chapter_resources_from_novel(self, novel_id: str, novel_info: dict[str, Any]) -> list[Resource]:
|
||||
book_title = _normalize_space(str(novel_info.get("novel_name") or ""))
|
||||
author = _normalize_space(str(novel_info.get("author_nickname") or ""))
|
||||
description = _clean_html_text(str(novel_info.get("novel_info") or novel_info.get("novel_desc") or ""))
|
||||
chapters = self._flatten_chapter_items(self._chapter_list(novel_id))
|
||||
resources: list[Resource] = []
|
||||
|
||||
for index, item in enumerate(chapters, start=1):
|
||||
chapter_id = str(item.get("id") or "").strip()
|
||||
chapter_title = _normalize_space(str(item.get("name") or ""))
|
||||
if not chapter_id or not chapter_title:
|
||||
continue
|
||||
locked = bool(item.get("lock")) or bool(item.get("pay"))
|
||||
order = int(item.get("order") or index)
|
||||
source_id = f"{novel_id}:{chapter_id}"
|
||||
resources.append(
|
||||
Resource(
|
||||
id=source_id,
|
||||
url=self._chapter_url(novel_id, chapter_id),
|
||||
title=chapter_title,
|
||||
author=author,
|
||||
author_id=str(novel_info.get("author_id") or ""),
|
||||
files=[],
|
||||
metadata={
|
||||
"kind": "novel_chapter",
|
||||
"resource_type": "novel",
|
||||
"content_type": "novel",
|
||||
"source_platform": "changpei",
|
||||
"source_id": source_id,
|
||||
"novel_id": novel_id,
|
||||
"book_id": novel_id,
|
||||
"book_title": book_title,
|
||||
"series_id": novel_id,
|
||||
"series_title": book_title,
|
||||
"chapter_id": chapter_id,
|
||||
"chapter_title": chapter_title,
|
||||
"chapter_order": order,
|
||||
"description": description,
|
||||
"locked": locked,
|
||||
"last_update": str(novel_info.get("novel_uptime") or ""),
|
||||
"book_status": str(novel_info.get("novel_process") or ""),
|
||||
},
|
||||
)
|
||||
)
|
||||
return resources
|
||||
|
||||
def _chapter_resource_from_ids(self, novel_id: str, chapter_id: str, *, source_url: str = "") -> Resource:
|
||||
data = self._chapter_data_from_api(novel_id, chapter_id)
|
||||
return Resource(
|
||||
id=str(data["source_id"]),
|
||||
url=source_url or self._chapter_url(novel_id, chapter_id),
|
||||
title=str(data["chapter_title"]),
|
||||
author=str(data.get("author") or ""),
|
||||
author_id="",
|
||||
files=[],
|
||||
metadata={
|
||||
"kind": "novel_chapter",
|
||||
"resource_type": "novel",
|
||||
"content_type": "novel",
|
||||
"source_platform": "changpei",
|
||||
"source_id": str(data["source_id"]),
|
||||
"novel_id": novel_id,
|
||||
"book_id": novel_id,
|
||||
"book_title": str(data.get("book_title") or ""),
|
||||
"series_id": novel_id,
|
||||
"series_title": str(data.get("book_title") or ""),
|
||||
"chapter_id": chapter_id,
|
||||
"chapter_title": str(data["chapter_title"]),
|
||||
"chapter_order": int(data.get("chapter_order") or 1),
|
||||
"description": str(data.get("description") or ""),
|
||||
"content": str(data.get("content") or ""),
|
||||
"word_count": int(data.get("word_count") or 0),
|
||||
"locked": bool(data.get("locked")),
|
||||
},
|
||||
)
|
||||
|
||||
def _resolve_novel_id(self, novel_id: str) -> dict[str, Any]:
|
||||
novel_info = self._novel_info(novel_id)
|
||||
resources = self._chapter_resources_from_novel(novel_id, novel_info)
|
||||
if not resources:
|
||||
raise PluginParseError(f"书籍 {novel_id} 没有解析到章节目录。")
|
||||
book_title = str(resources[0].metadata.get("book_title") or "")
|
||||
return {
|
||||
"mode": "chapters",
|
||||
"book_title": book_title,
|
||||
"resources": resources,
|
||||
}
|
||||
|
||||
# ---- cookie config (matches Pixiv / AO3 pattern) ----
|
||||
|
||||
def get_config_schema(self) -> dict[str, Any]:
|
||||
return {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cookie": {
|
||||
"type": "string",
|
||||
"title": "长佩 Cookie",
|
||||
"description": "粘贴长佩 (gongzicp.com) 登录后的 Cookie 文本,用于访问已购章节。",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
def load_config(self) -> dict[str, Any]:
|
||||
return {"cookie": self.cookie}
|
||||
|
||||
def save_config(self, data: dict[str, Any]) -> None:
|
||||
self.cookie = str(data.get("cookie") or "")
|
||||
self.session.headers.update(self.get_headers())
|
||||
|
||||
|
||||
plugin_class = ChangpeiPlugin
|
||||
Reference in new issue
Block a user