投稿接口

"""投稿用的上传工具：和「接口文档」页的 acg_client.py 放在同一个目录。

环境变量同 acg_client.py（ACG_API、ACG_TOKEN）。from acg_upload import * 会把 call、pages 这些一起导入。
"""
import base64
import os
import time
from urllib.parse import urljoin

import requests

from acg_client import *  # noqa: F401,F403  call、unwrap、APIError、API、session……


class Grant:
    """一张上传令牌（POST /submissions/{id}/upload-tokens）。一小时有效，用到 50 分钟自动换新的。"""

    def __init__(self, submission_id, purpose):
        self.submission_id, self.purpose = submission_id, purpose
        self.renew()

    def renew(self):
        self.g = call("POST", f"/submissions/{self.submission_id}/upload-tokens", {"purpose": self.purpose})
        self.renew_at = time.monotonic() + 50 * 60

    def headers(self, **extra):
        if time.monotonic() > self.renew_at:
            self.renew()
        return {"Authorization": "Bearer " + self.g["token"], **extra}


def upload_image(grant, path):
    """一张图片直传文件服务（purpose 是 images、cover），返回媒体的 uid：先要上传地址，再把文件传过去。"""
    body = {**grant.g["fields"], "size": os.path.getsize(path), "filename": os.path.basename(path), "wait": 10}
    for attempt in range(6):
        try:
            addr = unwrap(requests.post(grant.g["endpoints"]["upload_url"], headers=grant.headers(), json=body, timeout=60))
            break
        except APIError as e:
            if e.code != 60044 or attempt == 5:  # 60044：暂时没有能收文件的服务器，过一会儿再要
                raise
            time.sleep(30)
    for attempt in range(3):
        try:
            with open(path, "rb") as f:
                resp = requests.post(addr["url"], headers=grant.headers(), files={"file": (os.path.basename(path), f)}, timeout=600)
            return unwrap(resp)["uid"]
        except requests.RequestException:  # 没收到响应：同一个文件再传到同一个地址（收齐了的直接回结果）
            if attempt == 2:  # 放弃：撤掉要到的地址，不占「同时没传完的」名额
                try:
                    requests.delete(grant.g["endpoints"]["resumable"].rstrip("/") + "/" + addr["id"],
                                    headers={**grant.headers(), "Tus-Resumable": "1.0.0"}, timeout=60)
                except requests.RequestException:
                    pass
                raise
            time.sleep(5)


def tus_upload(create_url, path, metadata, auth, chunk_size, on_401=None):
    """tus 1.0.0 断点续传一个文件，返回上传的地址。auth() 给每次请求的鉴权头；收到 401 时调 on_401()（换令牌）。"""
    size = os.path.getsize(path)
    meta = ",".join(f"{k} {base64.b64encode(str(v).encode()).decode()}" for k, v in metadata.items())
    tus = {"Tus-Resumable": "1.0.0"}
    resp = requests.post(create_url, headers={**auth(), **tus, "Upload-Length": str(size), "Upload-Metadata": meta}, timeout=60)
    if resp.status_code != 201:
        unwrap(resp)  # 抛出错误；HTTP 429 是同时没传完的上传太多，过一会儿再传
    url = urljoin(create_url, resp.headers["Location"])  # 可能是别的域名（收上传的节点），照它发
    offset, failures = 0, 0
    with open(path, "rb") as f:
        while offset < size:
            f.seek(offset)
            try:
                resp = requests.patch(url, data=f.read(chunk_size), timeout=600, headers={
                    **auth(), **tus, "Upload-Offset": str(offset), "Content-Type": "application/offset+octet-stream"})
                if resp.status_code == 204:
                    offset, failures = int(resp.headers["Upload-Offset"]), 0
                    continue
                if resp.status_code == 401 and on_401:
                    on_401()
            except requests.RequestException:
                pass
            failures += 1
            if failures > 10:  # 放弃：撤掉这个上传，不然一直占着「同时没传完的」名额
                try:
                    requests.delete(url, headers={**auth(), **tus}, timeout=60)
                except requests.RequestException:
                    pass  # 撤不掉也行：名额满的时候闲着的会被收回
                raise RuntimeError(f"{path}: 连续传不上去，稍后重新运行（从头传）")
            time.sleep(min(60, 3 * failures))  # 断了、423（上一块还没收完）、5xx：等一会儿，问清传到哪了再接着传
            head = requests.head(url, headers={**auth(), **tus}, timeout=60)
            if head.status_code == 200:
                offset = int(head.headers["Upload-Offset"])
            elif head.status_code == 404:
                raise RuntimeError(f"{path}: 上传过期、不存在或者闲太久被收回了，要重新传")
    return url


def upload_media(grant, path, archive=False):
    """压缩包（还有换文件）用断点续传传给文件服务，等文件服务收尾：返回结果，压缩包看 ["archive_id"]。
    新传的视频、音频用 upload_av：传完就登记，不用等收尾。"""
    metadata = dict(grant.g["fields"], filename=os.path.basename(path))
    if archive:
        metadata["archive"] = "zip"
    url = tus_upload(grant.g["endpoints"]["resumable"], path, metadata, grant.headers, grant.g["chunk_size"], grant.renew)
    while True:
        result = unwrap(requests.get(url, params={"wait": 30}, headers=grant.headers(), timeout=60))
        if result["status"] == "done":
            return result
        if result["status"] == "failed":
            raise APIError(result["error"]["code"], result["error"]["message"])


def upload_av(grant, path, unit_id=None):
    """视频、音频用断点续传传给文件服务，传完就登记到 unit_id 那一集（不给是最后一集），返回登记（RemoteDownload）。
    之后站点等文件服务收尾、自动挂上，不用等；要等挂上用 wait_attached。"""
    metadata = dict(grant.g["fields"], filename=os.path.basename(path))
    url = tus_upload(grant.g["endpoints"]["resumable"], path, metadata, grant.headers, grant.g["chunk_size"], grant.renew)
    body = {"upload_id": url.rstrip("/").rsplit("/", 1)[-1], "purpose": grant.purpose, "filename": os.path.basename(path)}
    if unit_id:
        body["unit_id"] = unit_id
    return call("POST", f"/submissions/{grant.submission_id}/remote-downloads", body)


def wait_attached(submission_id, download, timeout=3600):
    """等一个登记的上传（或者填的链接）挂上，返回挂上的条目 id。失败抛 APIError；等太久抛 TimeoutError（之后照样会自动挂上）。"""
    deadline = time.monotonic() + timeout
    while download["status"] not in ("done", "failed", "canceled"):
        if time.monotonic() > deadline:
            raise TimeoutError("还在收尾，收好以后会自动挂上")
        time.sleep(5)
        items = call("GET", f"/submissions/{submission_id}/remote-downloads")["items"]
        download = next(d for d in items if d["id"] == download["id"])
    if download["status"] != "done":
        error = download.get("error") or {}
        raise APIError(error.get("code", -1), error.get("message", download["status"]))
    return download["item_id"]


def wait_archive(submission_id, archive):
    """登记好的压缩包等它解完，返回解压报告（ArchiveImport）。"""
    while archive["status"] in ("queued", "processing"):
        time.sleep((archive.get("poll_after_ms") or 2000) / 1000)
        archive = call("GET", f"/submissions/{submission_id}/archives/{archive['archive_id']}")
    if archive["status"] == "failed":
        raise APIError(72008, "archive rejected", archive["error"])
    return archive


def fill(submission, form):
    """填信息（只改带了的字段），返回改后的投稿。"""
    return call("PATCH", f"/submissions/{submission['id']}", {"version": submission["version"], "form": form})


def submit(submission_id):
    """提交审核。还有 problems 时抛 APIError（72004，data.problems 是原因）。"""
    sub = call("GET", f"/submissions/{submission_id}")
    return call("POST", f"/submissions/{submission_id}/submit", {"version": sub["version"]})


def category_id(content_type, code):
    """按分类的代码找 id（/meta 的 categories）。"""
    meta = call("GET", "/meta")
    return next(c["id"] for c in meta["categories"] if c["content_type"] == content_type and c["code"] == code)

POST /submissions                          建草稿（定内容类型）
  → POST /submissions/{id}/upload-tokens   要上传令牌
  → 把文件直接传给文件服务                    单张图片一个请求；视频、音频、压缩包用断点续传
  → 告诉投稿传了什么                        图片、视频、音频：POST …/media；压缩包：POST …/archives
  → GET / PUT …/structure                  排好单元（话、集）和顺序、选封面
  → PATCH /submissions/{id}                填信息
  → POST …/submit                          提交：审核通过后发布；免审的直接发布

curl -s -X POST "$ACG_API/submissions" -H "Authorization: Bearer $ACG_TOKEN" \
     -H "Content-Type: application/json" -H "Idempotency-Key: $(uuidgen)" -d '{"content_type": "manga"}'

# UPLOAD_URL_API、UPLOAD_TOKEN 是令牌的 endpoints.upload_url、token；fields 里有几项就加进 JSON（图片的一般是空的）
URL=$(curl -s -X POST "$UPLOAD_URL_API" -H "Authorization: Bearer $UPLOAD_TOKEN" -H "Content-Type: application/json" \
  -d "{\"size\": $(stat -c %s 001.jpg), \"filename\": \"001.jpg\", \"wait\": 10}" | jq -r .data.url)
curl -s -X POST "$URL" -H "Authorization: Bearer $UPLOAD_TOKEN" -F "file=@001.jpg"

from acg_upload import *

sub = call("POST", "/submissions", {"content_type": "manga"}, idempotent=True)
result = upload_media(Grant(sub["id"], "archive"), "第1話.zip", archive=True)
report = call("POST", f"/submissions/{sub['id']}/archives", {"archive_id": result["archive_id"], "unit_title": "第1话"})
report = wait_archive(sub["id"], report)  # 解完：report["units"] 是建出来的话，report["skipped_items"] 是跳过的文件和原因

g = Grant(sub["id"], "images")
uids = [upload_image(g, f"{n:03d}.jpg") for n in range(1, 33)]
structure = call("POST", f"/submissions/{sub['id']}/media", {"uids": uids})   # 按给的顺序挂到最后一话

{ "version": 5, "cover_item_id": 5001,
  "units": [ { "id": 101, "title": "第1话", "item_ids": [5001, 5002] },
             { "id": null, "title": "第2话", "item_ids": [5003] } ],
  "removed_item_ids": [5004] }

sub = call("POST", "/submissions", {"content_type": "anime"}, idempotent=True)
st = call("GET", f"/submissions/{sub['id']}/structure")
st = call("PUT", f"/submissions/{sub['id']}/structure", {"version": st["version"], "cover_item_id": None, "removed_item_ids": [],
          "units": [{"id": None, "title": f"第{n}集", "item_ids": []} for n in (1, 2)]})
g = Grant(sub["id"], "videos")
for unit, path in zip(st["units"], ["ep01.mkv", "ep02.mkv"]):
    upload_av(g, path, unit["id"])  # 传完就登记：站点等文件服务收尾、挂到这一集，不用等

d = call("POST", f"/submissions/{sub['id']}/remote-downloads", {"url": "https://files.example.com/ep03.mkv", "purpose": "videos",
         "unit_id": unit_id})

sub = call("POST", "/submissions", {"content_type": "novel"}, idempotent=True)
work = sub["work_id"]
chunk = call("GET", "/site")["limits"]["novel_import_chunk_bytes"]
url = tus_upload(f"{API}/me/works/{work}/import-uploads", "星海旅人.txt", {"filename": "星海旅人.txt"},
                 lambda: {"Authorization": session.headers["Authorization"]}, chunk)
imp = call("POST", f"/me/works/{work}/imports", {"upload_id": url.rsplit("/", 1)[1]})
# imp["outline"] 是切出来的卷和章，看一眼对不对；不对就 PATCH 改切章规则或大纲
imp = call("POST", f"/me/works/{work}/imports/{imp['id']}/apply", {"fill_form": True})
while imp["status"] == "applying":
    time.sleep(1)
    imp = call("GET", f"/me/works/{work}/imports/{imp['id']}")

ov = call("GET", f"/me/works/{work}/chapters")                         # 卷和章的概览，带 version
made = call("POST", f"/me/works/{work}/chapters", {"version": ov["version"], "title": "第一章 星海"})
chapter = made["chapter"]
call("PUT", f"/me/works/{work}/chapters/{chapter['id']}/body", {"version": 0, "body": "那一年，星海还没有名字。"})

sub = call("GET", f"/submissions/{sub['id']}")
sub = fill(sub, {
    "titles": [{"text": "夏日的约定", "lang": "zh"}, {"text": "夏の約束", "lang": "ja", "original": True}],
    "category_id": category_id("manga", "doujinshi"),
    "rating": "r18", "language": "zh", "translation_status": "translated",
    "description": "简介，可以用 **Markdown**。",
    "tags": [{"namespace": "female", "name": "双马尾"}, {"namespace": "artist", "name": "某某"}],
    "creators": [{"name": "某某", "role": "author"}],
})

sub = call("POST", "/submissions", {"kind": "new_units", "work_id": 12}, idempotent=True)
st = call("GET", f"/submissions/{sub['id']}/structure")
st = call("PUT", f"/submissions/{sub['id']}/structure", {"version": st["version"], "cover_item_id": None, "removed_item_ids": [],
          "units": [{"id": None, "title": "第3集", "item_ids": []}]})
upload_av(Grant(sub["id"], "videos"), "ep03.mkv", st["units"][0]["id"])  # 传完就登记，收好以后自动挂上
sub = call("GET", f"/submissions/{sub['id']}")
sub = call("PATCH", f"/submissions/{sub['id']}", {"version": sub["version"], "publish_at": "2026-10-20T23:30:00+09:00"})  # 定时，可选
submit(sub["id"])

sub = call("POST", "/submissions", {"kind": "work_edit", "work_id": 12})
sub = fill(sub, {"description": "新的简介", "serial_status": "completed"})
submit(sub["id"])

full = call("GET", "/me/works/12/structure")              # 作品现在的全部单元（各自的上线状态）
eps = [u["id"] for u in full["units"][:3]]                  # 要改的几集
sub = call("POST", "/submissions", {"kind": "unit_edit", "work_id": 12, "unit_ids": eps})
st = call("GET", f"/submissions/{sub['id']}/structure")   # 这几集的副本：在这里改