scripttrace 0.1.0__py3-none-any.whl

scripttrace/__init__.py

@@ -0,0 +1,3 @@
+"""Local screenplay labeling with side-by-side change traces."""
+
+__version__ = "0.1.0"

scripttrace/__main__.py

@@ -0,0 +1,4 @@
+from scripttrace.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripttrace/cli.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+import uvicorn
+
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 8765
+
+_EPILOG = """
+示例:
+  scripttrace serve
+  scripttrace serve --port 9000
+  scripttrace serve -p 9000 --data-dir D:\\labels
+  scripttrace serve --help
+""".strip()
+
+
+def _port_type(value: str) -> int:
+    try:
+        port = int(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("端口必须是整数") from exc
+    if not 1 <= port <= 65535:
+        raise argparse.ArgumentTypeError("端口必须在 1–65535")
+    return port
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="scripttrace",
+        description="本地剧本对照标注：上传 Markdown/Word，左右对照改稿并导出 JSON。原文只读。",
+        epilog=_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True, metavar="命令")
+
+    serve = sub.add_parser(
+        "serve",
+        help="启动本地网页（可用 --port 改端口）",
+        description="启动本地对照标注网页。默认地址 http://127.0.0.1:8765",
+        epilog=(
+            "示例:\n"
+            "  scripttrace serve\n"
+            "  scripttrace serve --port 9000\n"
+            "  scripttrace serve -p 9000 --host 0.0.0.0 --data-dir D:\\labels"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    serve.add_argument(
+        "--host",
+        default=os.environ.get("SCRIPTTRACE_HOST", DEFAULT_HOST),
+        help="监听地址，默认 %(default)s（本机）。局域网访问可用 0.0.0.0。"
+        "也可用环境变量 SCRIPTTRACE_HOST。",
+    )
+    serve.add_argument(
+        "-p",
+        "--port",
+        type=_port_type,
+        default=_port_type(os.environ.get("SCRIPTTRACE_PORT", str(DEFAULT_PORT))),
+        metavar="PORT",
+        help="监听端口，默认 %(default)s。例如: scripttrace serve --port 9000。"
+        "也可用环境变量 SCRIPTTRACE_PORT。",
+    )
+    serve.add_argument(
+        "--data-dir",
+        default=os.environ.get("SCRIPTTRACE_HOME"),
+        metavar="DIR",
+        help="项目数据目录，默认 ~/.scripttrace/projects。也可用环境变量 SCRIPTTRACE_HOME。",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.cmd == "serve":
+        if args.data_dir:
+            os.environ["SCRIPTTRACE_HOME"] = str(Path(args.data_dir).expanduser())
+        url_host = "127.0.0.1" if args.host in {"0.0.0.0", "::"} else args.host
+        print(f"scripttrace 已启动：http://{url_host}:{args.port}", flush=True)
+        uvicorn.run(
+            "scripttrace.server:app",
+            host=args.host,
+            port=args.port,
+            reload=False,
+        )
+        return 0
+    return 1

scripttrace/diff.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import difflib
+from typing import Literal
+
+Op = Literal["equal", "delete", "insert"]
+
+
+def iter_ops(original: str, revised: str) -> list[dict]:
+    """Character-level opcodes compatible with training export."""
+    matcher = difflib.SequenceMatcher(a=original, b=revised, autojunk=False)
+    ops: list[dict] = []
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            ops.append({"op": "equal", "text": original[i1:i2]})
+        elif tag == "delete":
+            ops.append({"op": "delete", "text": original[i1:i2]})
+        elif tag == "insert":
+            ops.append({"op": "insert", "text": revised[j1:j2]})
+        elif tag == "replace":
+            if i1 != i2:
+                ops.append({"op": "delete", "text": original[i1:i2]})
+            if j1 != j2:
+                ops.append({"op": "insert", "text": revised[j1:j2]})
+    return ops
+
+
+def changed(original: str, revised: str) -> bool:
+    return original != revised

scripttrace/parse.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from docx import Document
+
+_EPISODE_RE = re.compile(r"^(?:#{1,3}\s*)?(?:第\s*(\d+)\s*集|EPISODE\s+(\d+))\b", re.I)
+_SCENE_RE = re.compile(
+    r"^(?:#{1,3}\s*|\*\*)?(?:场景|場次|SCENE)\s*[:：]?\s*([^\s*]+)",
+    re.I,
+)
+_SCENE_HEADING_RE = re.compile(
+    r"^(?:\*\*)?(INT\.?/EXT\.?|INT\.?|EXT\.?|内景|外景|内\/外)",
+    re.I,
+)
+_MD_HEADING_RE = re.compile(r"^(#{1,6})\s+(.+)$")
+_BOLD_RE = re.compile(r"^\*\*(.+?)\*\*\s*$")
+_SPEAKER_LINE_RE = re.compile(
+    r"^[*＿_]*([\u4e00-\u9fffA-Za-z0-9·•]{1,20})[*＿_]*\s*[：:]\s*(.*)$"
+)
+_CUE_RE = re.compile(r"^[*＿_]*([\u4e00-\u9fffA-Za-z0-9·•]{1,20})[*＿_]*$")
+_ACTION_RE = re.compile(r"^[△▲∆▲]")
+
+
+def load_text(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in {".md", ".markdown", ".txt", ".fountain"}:
+        raw = path.read_bytes()
+        for enc in ("utf-8-sig", "utf-8", "gb18030"):
+            try:
+                return raw.decode(enc)
+            except UnicodeDecodeError:
+                continue
+        raise ValueError("无法识别文本编码，请另存为 UTF-8")
+    if suffix in {".docx"}:
+        doc = Document(str(path))
+        return "\n".join(p.text for p in doc.paragraphs)
+    raise ValueError(f"不支持的文件类型: {suffix}（请上传 .md / .txt / .docx）")
+
+
+def parse_screenplay(text: str) -> list[dict]:
+    """Split a screenplay into labeled blocks for side-by-side editing."""
+    lines = text.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    blocks: list[dict] = []
+    episode = ""
+    scene = ""
+    pending_speaker: str | None = None
+    scene_index = 0
+
+    def add(kind: str, body: str, speaker: str | None = None) -> None:
+        nonlocal scene
+        body = body.strip("\n")
+        if body.strip() == "" and kind == "other":
+            return
+        sid = scene
+        if kind == "scene" and not sid:
+            sid = str(scene_index)
+        blocks.append(
+            {
+                "id": f"b{len(blocks) + 1:04d}",
+                "kind": kind,
+                "original": body,
+                "revised": body,
+                "speaker": speaker,
+                "episode": episode or None,
+                "scene": sid or None,
+                "note": "",
+                "score": None,
+            }
+        )
+
+    i = 0
+    while i < len(lines):
+        raw = lines[i]
+        stripped = raw.strip()
+        if stripped in {"", "---", "***", "* * *"}:
+            pending_speaker = None
+            i += 1
+            continue
+
+        ep = _EPISODE_RE.match(stripped.strip("*").strip())
+        if ep:
+            episode = ep.group(1) or ep.group(2)
+            scene = ""
+            pending_speaker = None
+            add("episode", stripped)
+            i += 1
+            continue
+
+        sc = _SCENE_RE.match(stripped.strip("*").strip())
+        if sc or _SCENE_HEADING_RE.match(stripped.strip("*").strip()):
+            scene_index += 1
+            scene = (sc.group(1).strip() if sc else stripped.strip("*").strip())[:40]
+            pending_speaker = None
+            add("scene", stripped)
+            i += 1
+            continue
+
+        heading = _MD_HEADING_RE.match(stripped)
+        if heading:
+            pending_speaker = None
+            add("heading", stripped)
+            i += 1
+            continue
+
+        speaker_line = _SPEAKER_LINE_RE.match(stripped)
+        if speaker_line:
+            pending_speaker = None
+            add("dialogue", speaker_line.group(2).strip(), speaker_line.group(1))
+            i += 1
+            continue
+
+        bold = _BOLD_RE.match(stripped)
+        cue = _CUE_RE.match(stripped.strip("*").strip())
+        looks_cue = False
+        name = None
+        if bold:
+            name = bold.group(1).strip()
+            looks_cue = 1 <= len(name) <= 20 and "：" not in name and ":" not in name
+        elif cue and not _ACTION_RE.match(stripped):
+            name = cue.group(1)
+            looks_cue = len(name) <= 16 and not stripped.endswith("。")
+
+        if looks_cue and name:
+            nxt = lines[i + 1].strip() if i + 1 < len(lines) else ""
+            if nxt and not _SPEAKER_LINE_RE.match(nxt) and not _MD_HEADING_RE.match(nxt):
+                pending_speaker = None
+                add("dialogue", nxt, name)
+                i += 2
+                continue
+            pending_speaker = name
+            i += 1
+            continue
+
+        if pending_speaker:
+            add("dialogue", stripped, pending_speaker)
+            pending_speaker = None
+            i += 1
+            continue
+
+        kind = "action" if _ACTION_RE.match(stripped) else "other"
+        add(kind, stripped)
+        i += 1
+
+    if not blocks:
+        add("other", text.strip() or text)
+    return blocks

scripttrace/server.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from urllib.parse import quote
+
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.responses import FileResponse, JSONResponse, PlainTextResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+from scripttrace.diff import iter_ops
+from scripttrace.store import ProjectStore, default_root
+
+STATIC_DIR = Path(__file__).resolve().parent / "static"
+
+
+def get_store() -> ProjectStore:
+    home = os.environ.get("SCRIPTTRACE_HOME")
+    return ProjectStore(Path(home) if home else default_root())
+
+
+def attachment_headers(filename: str, fallback: str) -> dict[str, str]:
+    """Build a latin-1-safe Content-Disposition so Chinese titles can download."""
+    safe = (
+        filename.replace("\\", "_")
+        .replace("/", "_")
+        .replace('"', "")
+        .replace("\r", "")
+        .replace("\n", "")
+    )
+    ascii_name = "".join(ch if 32 <= ord(ch) < 127 else "_" for ch in safe)
+    ascii_name = ascii_name.strip("._") or fallback
+    return {
+        "Content-Disposition": (
+            f'attachment; filename="{ascii_name}"; filename*=UTF-8\'\'{quote(safe, safe="._-")}'
+        )
+    }
+
+
+app = FastAPI(title="scripttrace", version="0.1.0")
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+
+class SaveBody(BaseModel):
+    title: str | None = None
+    blocks: list[dict] = Field(default_factory=list)
+
+
+class RenameBody(BaseModel):
+    title: str
+
+
+class DiffBody(BaseModel):
+    original: str
+    revised: str
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(STATIC_DIR / "index.html")
+
+
+@app.get("/api/projects")
+def list_projects() -> list[dict]:
+    return get_store().list_projects()
+
+
+@app.post("/api/projects")
+async def create_project(file: UploadFile = File(...)) -> JSONResponse:
+    name = file.filename or "upload.md"
+    suffix = Path(name).suffix.lower()
+    if suffix not in {".md", ".markdown", ".txt", ".docx", ".fountain"}:
+        raise HTTPException(400, "请上传 .md / .txt / .docx")
+    raw = await file.read()
+    if len(raw) > 20 * 1024 * 1024:
+        raise HTTPException(400, "文件超过 20MB")
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        tmp.write(raw)
+        tmp_path = Path(tmp.name)
+    try:
+        data = get_store().create_from_file(tmp_path, name)
+    except ValueError as exc:
+        raise HTTPException(400, str(exc)) from exc
+    finally:
+        tmp_path.unlink(missing_ok=True)
+    return JSONResponse(data)
+
+
+@app.get("/api/projects/{project_id}")
+def get_project(project_id: str) -> dict:
+    try:
+        return get_store().get(project_id)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+
+
+@app.put("/api/projects/{project_id}")
+def save_project(project_id: str, body: SaveBody) -> dict:
+    try:
+        return get_store().save_blocks(project_id, body.blocks, title=body.title)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+
+
+@app.patch("/api/projects/{project_id}")
+def rename_project(project_id: str, body: RenameBody) -> dict:
+    try:
+        return get_store().rename(project_id, body.title)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+
+
+@app.delete("/api/projects/{project_id}")
+def delete_project(project_id: str) -> dict:
+    try:
+        get_store().delete(project_id)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+    return {"ok": True}
+
+
+@app.post("/api/diff")
+def diff_text(body: DiffBody) -> dict:
+    return {"ops": iter_ops(body.original, body.revised)}
+
+
+@app.get("/api/projects/{project_id}/export.json")
+def export_json(project_id: str) -> JSONResponse:
+    try:
+        payload = get_store().export_payload(project_id)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+    filename = f"{payload.get('title') or project_id}.scripttrace.json"
+    return JSONResponse(
+        payload,
+        headers=attachment_headers(filename, f"{project_id}.scripttrace.json"),
+    )
+
+
+@app.get("/api/projects/{project_id}/export.sft.jsonl")
+def export_sft(project_id: str) -> PlainTextResponse:
+    try:
+        payload = get_store().export_payload(project_id)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+    lines = [json.dumps(row, ensure_ascii=False) for row in payload.get("sft") or []]
+    filename = f"{payload.get('title') or project_id}.sft.jsonl"
+    return PlainTextResponse(
+        "\n".join(lines) + ("\n" if lines else ""),
+        media_type="application/jsonl; charset=utf-8",
+        headers=attachment_headers(filename, f"{project_id}.sft.jsonl"),
+    )
+
+
+@app.get("/api/projects/{project_id}/export.trace.json")
+def export_trace(project_id: str) -> JSONResponse:
+    try:
+        payload = get_store().export_trace(project_id)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc
+    filename = f"{payload.get('title') or project_id}.trace.json"
+    return JSONResponse(
+        payload,
+        headers=attachment_headers(filename, f"{project_id}.trace.json"),
+    )
+
+
+@app.get("/api/projects/{project_id}/preview")
+def preview_project(project_id: str) -> dict:
+    try:
+        return get_store().preview_payload(project_id)
+    except FileNotFoundError as exc:
+        raise HTTPException(404, "项目不存在") from exc