Pythonでnoteの下書きを自動作成・保存する

"""
下書きを1本作成して本文を保存する、最小の実装。
"""
from note_auth_client import NoteAuthClient, CookieExpiredError


def create_empty_draft(client: NoteAuthClient) -> dict:
    """空の下書きを作成し、id と key を返す"""
    data = client.post_json("/api/v1/text_notes", payload={})

    note_id = data.get("id")
    note_key = data.get("key")

    if not note_id:
        raise RuntimeError(f"下書きの作成に失敗しました: {data}")

    print(f"下書きを作成しました（id={note_id} / key={note_key}）")
    return {"id": note_id, "key": note_key}


def save_draft(client: NoteAuthClient, note_id: int,
               title: str, body_html: str) -> bool:
    """作成済みの下書きにタイトルと本文を保存する"""
    payload = {
        "name": title,
        "body": body_html,
    }

    res = client.request(
        "POST",
        "/api/v1/text_notes/draft_save",
        params={"id": note_id},
        json=payload,
    )

    if res.status_code not in (200, 201):
        print(f"保存に失敗しました: HTTP {res.status_code}")
        print(res.text[:300])
        return False

    print("本文を保存しました")
    return True


if __name__ == "__main__":
    try:
        client = NoteAuthClient()
        client.verify()

        draft = create_empty_draft(client)

        title = "APIから作成したテスト記事"
        body = (
            "<p>これはPythonから作成した下書きです。</p>"
            "<h2>見出しのテスト</h2>"
            "<p>本文には<strong>強調</strong>も使えます。</p>"
        )

        if save_draft(client, draft["id"], title, body):
            print(f"確認: https://note.com/notes/{draft['key']}/edit")

    except CookieExpiredError as e:
        print("認証エラー:", e)

"""
noteの下書き操作をまとめたクラス。
以降の記事でもこのモジュールを使う。
"""
import logging

from note_auth_client import NoteAuthClient

logger = logging.getLogger(__name__)


class NoteDraft:

    def __init__(self, client: NoteAuthClient):
        self.client = client

    # ---- 作成 ----

    def create(self, title: str, body_html: str) -> dict:
        """
        下書きを作成して本文まで保存する。
        成功したら {"id":..., "key":..., "title":...} を返す。
        """
        data = self.client.post_json("/api/v1/text_notes", payload={})
        note_id = data.get("id")
        note_key = data.get("key")

        if not note_id:
            raise RuntimeError(f"下書き枠の作成に失敗: {data}")

        ok = self.save(note_id, title, body_html)
        if not ok:
            logger.warning("枠は作成されましたが本文の保存に失敗しました "
                           "(id=%s)", note_id)

        return {
            "id": note_id,
            "key": note_key,
            "title": title,
            "saved": ok,
            "edit_url": f"https://note.com/notes/{note_key}/edit",
        }

    def save(self, note_id: int, title: str, body_html: str) -> bool:
        """既存の下書きを上書き保存する"""
        res = self.client.request(
            "POST",
            "/api/v1/text_notes/draft_save",
            params={"id": note_id},
            json={"name": title, "body": body_html},
        )

        if res.status_code not in (200, 201):
            logger.error("draft_save 失敗 HTTP %s: %s",
                         res.status_code, res.text[:200])
            return False
        return True

    # ---- 取得 ----

    def list_drafts(self, max_pages: int = 20) -> list:
        """下書きの一覧を取得する"""
        drafts = []

        for page in range(1, max_pages + 1):
            data = self.client.get_json(
                "/api/v3/notes",
                params={"kind": "note", "status": "draft", "page": page},
            )
            notes = data.get("notes", data.get("contents", []))
            if not notes:
                break

            drafts.extend(notes)

            if data.get("isLastPage") or data.get("is_last_page"):
                break

        return drafts

    def find_by_title(self, title: str) -> dict:
        """同じタイトルの下書きがあるか探す（重複防止用）"""
        for d in self.list_drafts():
            if (d.get("name") or "").strip() == title.strip():
                return d
        return {}

    # ---- 削除 ----

    def delete(self, note_id: int) -> bool:
        """下書きを削除する"""
        res = self.client.request(
            "DELETE",
            "/api/v1/text_notes/draft_delete",
            params={"id": note_id},
        )

        if res.status_code not in (200, 204):
            logger.error("削除失敗 HTTP %s", res.status_code)
            return False

        logger.info("下書きを削除しました (id=%s)", note_id)
        return True


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)

    client = NoteAuthClient()
    client.verify()

    draft = NoteDraft(client)
    result = draft.create(
        "クラス経由で作成したテスト",
        "<p>NoteDraft クラスから作成しました。</p>",
    )
    print(result)

"""
noteが受け付けるタグだけを残すサニタイザ。
標準ライブラリの HTMLParser を使うので追加インストール不要。
"""
from html.parser import HTMLParser
from html import escape

ALLOWED_TAGS = {
    "p", "h2", "h3", "ul", "ol", "li",
    "blockquote", "strong", "em", "s", "code", "a", "br",
}
ALLOWED_ATTRS = {"a": {"href"}}


class NoteSanitizer(HTMLParser):

    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.parts = []
        self.removed = set()

    def handle_starttag(self, tag, attrs):
        if tag not in ALLOWED_TAGS:
            self.removed.add(tag)
            return

        allowed = ALLOWED_ATTRS.get(tag, set())
        kept = [
            f'{k}="{escape(v or "")}"'
            for k, v in attrs if k in allowed
        ]

        if kept:
            self.parts.append(f"<{tag} {' '.join(kept)}>")
        else:
            self.parts.append(f"<{tag}>")

    def handle_endtag(self, tag):
        if tag in ALLOWED_TAGS and tag != "br":
            self.parts.append(f"</{tag}>")

    def handle_data(self, data):
        self.parts.append(escape(data))

    def result(self) -> str:
        return "".join(self.parts)


def sanitize(html: str, verbose: bool = True) -> str:
    """note用にHTMLを整形する"""
    parser = NoteSanitizer()
    parser.feed(html)
    parser.close()

    if verbose and parser.removed:
        print("除去したタグ:", ", ".join(sorted(parser.removed)))

    return parser.result()


if __name__ == "__main__":
    dirty = (
        '<div class="wrap"><p style="color:red">赤い文字</p>'
        '<span>スパン</span><h2>見出し</h2>'
        '<p><a href="https://example.com" target="_blank">リンク</a>'
        '</p><table><tr><td>表</td></tr></table></div>'
    )
    print(sanitize(dirty))

"""
drafts/ フォルダ内のテキストファイルを、noteの下書きとして一括作成する。

ファイル形式:
    1行目 = タイトル
    2行目以降 = 本文（空行で段落を区切る）

処理済みのファイルは done/ へ移動する。
"""
import os
import shutil
import time
from html import escape

from note_auth_client import NoteAuthClient, CookieExpiredError
from note_draft import NoteDraft

SOURCE_DIR = "drafts"
DONE_DIR = "drafts_done"
SLEEP_SEC = 3.0        # 下書き作成の間隔（余裕をもって）
MAX_PER_RUN = 10       # 1回の実行で作る上限


def text_to_html(text: str) -> str:
    """
    プレーンテキストをnote用のHTMLに変換する。
    - 空行で段落を分ける
    - 行頭の ## を見出しにする
    - 行頭の - をリストにする
    """
    blocks = [b.strip() for b in text.split("\n\n") if b.strip()]
    html_parts = []

    for block in blocks:
        lines = block.split("\n")

        # リストブロック
        if all(l.strip().startswith("- ") for l in lines):
            items = "".join(
                f"<li>{escape(l.strip()[2:])}</li>" for l in lines
            )
            html_parts.append(f"<ul>{items}</ul>")
            continue

        # 見出し
        if block.startswith("## "):
            html_parts.append(f"<h2>{escape(block[3:].strip())}</h2>")
            continue
        if block.startswith("### "):
            html_parts.append(f"<h3>{escape(block[4:].strip())}</h3>")
            continue

        # 引用
        if block.startswith("> "):
            body = escape(block[2:].strip())
            html_parts.append(f"<blockquote>{body}</blockquote>")
            continue

        # 通常の段落（内部の改行は br に）
        para = "<br>".join(escape(l) for l in lines)
        html_parts.append(f"<p>{para}</p>")

    return "".join(html_parts)


def read_file(path: str) -> tuple:
    """ファイルを読んで (タイトル, 本文HTML) を返す"""
    with open(path, encoding="utf-8") as f:
        content = f.read()

    lines = content.split("\n")
    title = lines[0].strip().lstrip("# ").strip()
    body_text = "\n".join(lines[1:]).strip()

    if not title:
        title = os.path.splitext(os.path.basename(path))[0]

    return title, text_to_html(body_text)


def main():
    if not os.path.isdir(SOURCE_DIR):
        print(f"{SOURCE_DIR}/ フォルダを作って、原稿を置いてください")
        return

    files = sorted(
        f for f in os.listdir(SOURCE_DIR)
        if f.endswith((".txt", ".md"))
    )

    if not files:
        print("処理対象のファイルがありません")
        return

    try:
        client = NoteAuthClient()
        client.verify()
    except CookieExpiredError as e:
        print("認証エラー:", e)
        return

    draft = NoteDraft(client)
    os.makedirs(DONE_DIR, exist_ok=True)

    created = 0

    for filename in files[:MAX_PER_RUN]:
        path = os.path.join(SOURCE_DIR, filename)
        title, body = read_file(path)

        # 同名の下書きがあればスキップ（二重投稿の防止）
        existing = draft.find_by_title(title)
        if existing:
            print(f"スキップ（既存）: {title}")
            continue

        print(f"作成中: {title}")
        try:
            result = draft.create(title, body)
            print(f"  → {result['edit_url']}")
            created += 1

            shutil.move(path, os.path.join(DONE_DIR, filename))

        except Exception as e:
            print(f"  エラー: {e}")

        time.sleep(SLEEP_SEC)

    print(f"\n完了: {created} 件の下書きを作成しました")


if __name__ == "__main__":
    main()

"""
下書きの一覧を取得して、状態を報告する。
- タイトル未設定のもの
- 本文が極端に短いもの
- 古いまま放置されているもの
"""
from datetime import datetime, timezone

from note_auth_client import NoteAuthClient, CookieExpiredError
from note_draft import NoteDraft

STALE_DAYS = 60


def parse_date(value: str):
    if not value:
        return None
    try:
        return datetime.fromisoformat(value.replace("Z", "+00:00"))
    except ValueError:
        return None


def report(drafts: list):
    if not drafts:
        print("下書きはありません")
        return

    now = datetime.now(timezone.utc)
    untitled = []
    short = []
    stale = []

    print(f"=== 下書き {len(drafts)} 件 ===\n")

    for d in drafts:
        title = (d.get("name") or "").strip()
        body = d.get("body") or ""
        updated = parse_date(
            d.get("updatedAt") or d.get("updated_at") or ""
        )

        label = title or "（無題）"
        age = ""
        if updated:
            days = (now - updated).days
            age = f"{days}日前"
            if days > STALE_DAYS:
                stale.append(label)

        print(f"  {label[:44]:<46}{len(body):>7}文字  {age}")

        if not title:
            untitled.append(d.get("id"))
        if len(body) < 300:
            short.append(label)

    print("\n=== 気になるもの ===")
    print(f"  タイトル未設定 : {len(untitled)} 件")
    print(f"  本文300文字未満: {len(short)} 件")
    print(f"  {STALE_DAYS}日以上放置  : {len(stale)} 件")

    if stale:
        print("\n  放置されている下書き:")
        for s in stale[:10]:
            print(f"    - {s[:50]}")
        print("\n  → 仕上げて公開するか、削除するか決めてください")


if __name__ == "__main__":
    try:
        client = NoteAuthClient()
        client.verify()

        draft = NoteDraft(client)
        report(draft.list_drafts())

    except CookieExpiredError as e:
        print("認証エラー:", e)

"""
条件に合う下書きを削除する。
実行前に必ず対象を表示し、確認を取る。
"""
import time

from note_auth_client import NoteAuthClient, CookieExpiredError
from note_draft import NoteDraft

# 削除対象の条件
TITLE_KEYWORDS = ["テスト", "test", "APIから作成"]
MIN_BODY_CHARS = 50


def find_targets(drafts: list) -> list:
    """削除候補を絞り込む"""
    targets = []

    for d in drafts:
        title = (d.get("name") or "").strip()
        body = d.get("body") or ""

        # テスト用のタイトルを含む
        if any(k.lower() in title.lower() for k in TITLE_KEYWORDS):
            targets.append((d, "テスト用タイトル"))
            continue

        # 中身がほぼ無い
        if len(body) < MIN_BODY_CHARS and title:
            targets.append((d, "本文がほぼ空"))

    return targets


def main():
    try:
        client = NoteAuthClient()
        client.verify()
    except CookieExpiredError as e:
        print("認証エラー:", e)
        return

    draft = NoteDraft(client)
    drafts = draft.list_drafts()
    targets = find_targets(drafts)

    if not targets:
        print("削除対象はありません")
        return

    print(f"=== 削除候補 {len(targets)} 件 ===")
    for d, reason in targets:
        title = (d.get("name") or "（無題）")[:44]
        print(f"  [{reason}] {title}")

    answer = input("\nこれらを削除しますか？ (yes / no): ").strip().lower()
    if answer != "yes":
        print("中止しました")
        return

    deleted = 0
    for d, _ in targets:
        note_id = d.get("id")
        if not note_id:
            continue

        if draft.delete(note_id):
            deleted += 1
        time.sleep(1.5)

    print(f"\n{deleted} 件を削除しました")


if __name__ == "__main__":
    main()