Markdown原稿をnote用HTMLに変換して投稿するPythonスクリプト

"""
インストール:
    pip install markdown

Markdown → note用HTML の変換。
変換後にサニタイズして、noteが受け付ける形に整える。
"""
import re

import markdown

from sanitize import sanitize   # 下書きの記事で作成したサニタイザ

# 有効にする拡張機能
EXTENSIONS = [
    "extra",        # 表・定義リストなど
    "sane_lists",   # リストの解釈を厳密に
    "nl2br",        # 改行をbrに変換
]


def md_to_html(md_text: str) -> str:
    """Markdownを素のHTMLに変換する"""
    return markdown.markdown(md_text, extensions=EXTENSIONS)


def adjust_headings(html: str) -> str:
    """
    見出しレベルをnote向けに調整する。
    h1 → h2、h4以降 → h3 に丸める。
    """
    html = re.sub(r"<(/?)h1>", r"<\1h2>", html)
    html = re.sub(r"<(/?)h[4-6]>", r"<\1h3>", html)
    return html


def convert_del_to_s(html: str) -> str:
    """del タグを s に置き換える"""
    return re.sub(r"<(/?)del>", r"<\1s>", html)


def to_note_html(md_text: str, verbose: bool = True) -> str:
    """Markdown原稿をnoteに投稿できるHTMLへ変換する"""
    html = md_to_html(md_text)
    html = adjust_headings(html)
    html = convert_del_to_s(html)
    html = table_to_list(html)
    return sanitize(html, verbose=verbose)


def table_to_list(html: str) -> str:
    """
    表はnoteで消えるため、リスト形式に展開する。
    ヘッダ行を項目名として、各行を「項目: 値」の形にする。
    """
    def replace(match):
        table_html = match.group(0)

        rows = re.findall(r"<tr>(.*?)</tr>", table_html, re.S)
        if not rows:
            return ""

        headers = re.findall(r"<th[^>]*>(.*?)</th>", rows[0], re.S)
        headers = [strip_tags(h) for h in headers]

        items = []
        for row in rows[1:]:
            cells = re.findall(r"<td[^>]*>(.*?)</td>", row, re.S)
            cells = [strip_tags(c) for c in cells]
            if not cells:
                continue

            if headers and len(headers) == len(cells):
                text = " / ".join(
                    f"{h}: {c}" for h, c in zip(headers, cells) if c
                )
            else:
                text = " / ".join(c for c in cells if c)

            if text:
                items.append(f"<li>{text}</li>")

        return f"<ul>{''.join(items)}</ul>" if items else ""

    return re.sub(r"<table.*?</table>", replace, html, flags=re.S)


def strip_tags(text: str) -> str:
    """タグを除去して中身のテキストだけにする"""
    return re.sub(r"<[^>]+>", "", text).strip()


if __name__ == "__main__":
    sample = """# タイトル見出し

これは**太字**と*斜体*と`コード`を含む段落です。

## セクション

- 項目1
- 項目2

> 引用文です。

| 名前 | 価格 |
|------|------|
| A商品 | 500円 |
| B商品 | 800円 |

[リンク](https://example.com)です。
"""
    print(to_note_html(sample))

"""
外部ライブラリを使わないMarkdown変換。
noteで使えるタグだけを出力するので、サニタイズ不要。
"""
import re
from html import escape


def inline(text: str) -> str:
    """インライン記法を変換する（エスケープ済みの文字列に対して適用）"""
    # コードは最初に処理して、中身を保護する
    codes = []

    def stash_code(m):
        codes.append(m.group(1))
        return f"\x00CODE{len(codes) - 1}\x00"

    text = re.sub(r"`([^`]+)`", stash_code, text)

    # エスケープ
    text = escape(text)

    # 太字 → strong
    text = re.sub(r"\*\*([^*]+)\*\*", r"<strong>\1</strong>", text)
    text = re.sub(r"__([^_]+)__", r"<strong>\1</strong>", text)

    # 斜体 → em
    text = re.sub(r"\*([^*]+)\*", r"<em>\1</em>", text)

    # 打ち消し → s
    text = re.sub(r"~~([^~]+)~~", r"<s>\1</s>", text)

    # リンク（画像記法は別扱いなので先に除外）
    text = re.sub(
        r"\[([^\]]+)\]\(([^)]+)\)",
        lambda m: f'<a href="{escape(m.group(2))}">{m.group(1)}</a>',
        text,
    )

    # 退避したコードを戻す
    for i, code in enumerate(codes):
        text = text.replace(
            f"\x00CODE{i}\x00",
            f"<code>{escape(code)}</code>",
        )

    return text


def convert(md_text: str) -> str:
    """Markdown原稿をnote用HTMLに変換する"""
    lines = md_text.split("\n")
    out = []
    i = 0
    n = len(lines)

    while i < n:
        line = lines[i]
        stripped = line.strip()

        # 空行
        if not stripped:
            i += 1
            continue

        # コードブロック（``` で囲まれた部分）
        if stripped.startswith("```"):
            i += 1
            buf = []
            while i < n and not lines[i].strip().startswith("```"):
                buf.append(lines[i])
                i += 1
            i += 1
            body = escape("\n".join(buf))
            # noteにpreは無いので、コード表記の段落として出す
            out.append(f"<p><code>{body}</code></p>")
            continue

        # 見出し
        m = re.match(r"^(#{1,6})\s+(.+)$", stripped)
        if m:
            level = len(m.group(1))
            tag = "h2" if level <= 2 else "h3"
            out.append(f"<{tag}>{inline(m.group(2))}</{tag}>")
            i += 1
            continue

        # 引用（連続する行をまとめる）
        if stripped.startswith(">"):
            buf = []
            while i < n and lines[i].strip().startswith(">"):
                buf.append(lines[i].strip().lstrip(">").strip())
                i += 1
            body = "<br>".join(inline(b) for b in buf if b)
            out.append(f"<blockquote>{body}</blockquote>")
            continue

        # 箇条書き
        if re.match(r"^[-*+]\s+", stripped):
            items = []
            while i < n and re.match(r"^[-*+]\s+", lines[i].strip()):
                content = re.sub(r"^[-*+]\s+", "", lines[i].strip())
                items.append(f"<li>{inline(content)}</li>")
                i += 1
            out.append(f"<ul>{''.join(items)}</ul>")
            continue

        # 番号付きリスト
        if re.match(r"^\d+\.\s+", stripped):
            items = []
            while i < n and re.match(r"^\d+\.\s+", lines[i].strip()):
                content = re.sub(r"^\d+\.\s+", "", lines[i].strip())
                items.append(f"<li>{inline(content)}</li>")
                i += 1
            out.append(f"<ol>{''.join(items)}</ol>")
            continue

        # 水平線はスキップ
        if re.match(r"^(-{3,}|\*{3,}|_{3,})$", stripped):
            i += 1
            continue

        # 表（連続する | の行をリストに変換）
        if stripped.startswith("|"):
            rows = []
            while i < n and lines[i].strip().startswith("|"):
                rows.append(lines[i].strip())
                i += 1
            out.append(table_lines_to_list(rows))
            continue

        # 通常の段落（連続する行を1段落にまとめる）
        buf = []
        while i < n and lines[i].strip() and not is_block_start(lines[i]):
            buf.append(lines[i].strip())
            i += 1
        if buf:
            body = "<br>".join(inline(b) for b in buf)
            out.append(f"<p>{body}</p>")

    return "".join(out)


def is_block_start(line: str) -> bool:
    """その行が新しいブロックの開始かを判定する"""
    s = line.strip()
    return bool(
        re.match(r"^#{1,6}\s", s)
        or re.match(r"^[-*+]\s", s)
        or re.match(r"^\d+\.\s", s)
        or s.startswith(">")
        or s.startswith("|")
        or s.startswith("```")
    )


def table_lines_to_list(rows: list) -> str:
    """Markdownの表をリストに変換する"""
    def cells(row: str) -> list:
        return [c.strip() for c in row.strip("|").split("|")]

    # 区切り行（|---|---|）を除去
    body = [r for r in rows if not re.match(r"^\|[\s:|-]+\|$", r)]
    if not body:
        return ""

    headers = cells(body[0])
    items = []

    for row in body[1:]:
        values = cells(row)
        if headers and len(headers) == len(values):
            text = " / ".join(
                f"{h}: {v}" for h, v in zip(headers, values) if v
            )
        else:
            text = " / ".join(v for v in values if v)
        if text:
            items.append(f"<li>{inline(text)}</li>")

    return f"<ul>{''.join(items)}</ul>" if items else ""


if __name__ == "__main__":
    sample = """## テスト見出し

これは**太字**と`コード`を含む段落です。
2行目もここに続きます。

- 項目A
- 項目B

> 引用です
> 2行目

| 名前 | 価格 |
|------|------|
| A | 500円 |
"""
    print(convert(sample))

"""
YAMLフロントマター付きMarkdownを解析する。
PyYAMLに依存しない簡易パーサ。

---
title: 記事のタイトル
tags: [Python, note, 自動化]
price: 0
---
本文...
"""
import re


def parse(content: str) -> tuple:
    """
    フロントマターと本文を分離する。
    戻り値: (メタ情報のdict, 本文のstr)
    """
    if not content.startswith("---"):
        return {}, content

    parts = content.split("---", 2)
    if len(parts) < 3:
        return {}, content

    meta_text = parts[1]
    body = parts[2].lstrip("\n")

    meta = {}
    for line in meta_text.split("\n"):
        line = line.strip()
        if not line or line.startswith("#") or ":" not in line:
            continue

        key, value = line.split(":", 1)
        key = key.strip()
        value = value.strip()

        # クォートを外す
        if value and value[0] in "\"'" and value[-1] == value[0]:
            value = value[1:-1]

        # 配列表記 [a, b, c]
        if value.startswith("[") and value.endswith("]"):
            items = [
                v.strip().strip("\"'")
                for v in value[1:-1].split(",")
            ]
            meta[key] = [v for v in items if v]
            continue

        # 数値
        if re.fullmatch(r"-?\d+", value):
            meta[key] = int(value)
            continue

        # 真偽値
        if value.lower() in ("true", "false"):
            meta[key] = value.lower() == "true"
            continue

        meta[key] = value

    return meta, body


def extract_title(meta: dict, body: str, fallback: str = "") -> str:
    """タイトルを決める。frontmatter → 本文のh1 → ファイル名の順"""
    if meta.get("title"):
        return str(meta["title"])

    m = re.search(r"^#\s+(.+)$", body, re.MULTILINE)
    if m:
        return m.group(1).strip()

    return fallback


def strip_title_heading(body: str) -> str:
    """本文冒頭のh1見出しを取り除く（タイトルと重複するため）"""
    return re.sub(r"^#\s+.+\n+", "", body, count=1)


if __name__ == "__main__":
    sample = """---
title: "テスト記事のタイトル"
tags: [Python, 自動化]
price: 500
draft: false
---

# 本文の見出し

ここから本文です。
"""
    meta, body = parse(sample)
    print("メタ情報:", meta)
    print("タイトル:", extract_title(meta, body))
    print("本文:", strip_title_heading(body)[:40])

"""
変換結果を検証し、note投稿時に問題になる箇所を報告する。
実際に投稿する前に必ず通す。
"""
import re

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

WARN_PATTERNS = [
    (r"<table", "表が残っています。noteでは表示されません"),
    (r"<img", "画像タグがあります。先にアップロードが必要です"),
    (r"<pre", "preタグは非対応です"),
    (r"<h1", "h1は使えません。h2に変換してください"),
    (r"<h[4-6]", "h4以降は使えません。h3に丸めてください"),
    (r'style\s*=', "style属性は除去されます"),
    (r"<div", "divは除去されます"),
    (r"<span", "spanは除去されます"),
]


def used_tags(html: str) -> set:
    return set(re.findall(r"<(\w+)", html))


def validate(html: str, verbose: bool = True) -> dict:
    """HTMLを検証して結果を返す"""
    tags = used_tags(html)
    disallowed = tags - ALLOWED_TAGS

    warnings = []
    for pattern, message in WARN_PATTERNS:
        if re.search(pattern, html, re.IGNORECASE):
            warnings.append(message)

    text_only = re.sub(r"<[^>]+>", "", html)
    text_length = len(re.sub(r"\s", "", text_only))

    result = {
        "ok": not disallowed and not warnings,
        "tags": sorted(tags),
        "disallowed": sorted(disallowed),
        "warnings": warnings,
        "text_length": text_length,
        "html_length": len(html),
    }

    if verbose:
        print("=== 変換結果の検証 ===")
        print(f"  本文の文字数 : {text_length:,} 文字")
        print(f"  HTMLの長さ   : {len(html):,} 文字")
        print(f"  使用タグ     : {', '.join(result['tags'])}")

        if disallowed:
            print(f"  非対応タグ   : {', '.join(result['disallowed'])}")

        if warnings:
            print("  警告:")
            for w in warnings:
                print(f"    - {w}")

        if result["ok"]:
            print("  → 問題ありません")

    return result


def preview(html: str, chars: int = 300):
    """変換後のテキストを目視確認する"""
    text = re.sub(r"<br>", "\n", html)
    text = re.sub(r"</(p|h2|h3|li|blockquote)>", "\n", text)
    text = re.sub(r"<[^>]+>", "", text)
    text = re.sub(r"\n{3,}", "\n\n", text)

    print("\n=== 本文プレビュー ===")
    print(text[:chars].strip())
    if len(text) > chars:
        print("...")


if __name__ == "__main__":
    from simple_md import convert

    sample = """## 見出し

本文です。**太字**もあります。

| A | B |
|---|---|
| 1 | 2 |
"""
    html = convert(sample)
    validate(html)
    preview(html)

"""
posts/ フォルダのMarkdownを、noteの下書きとして一括作成する。

    posts/
      2024-01-15-first.md
      2024-01-22-second.md

各ファイルはフロントマター付きでもよい。
処理済みは posts_done/ へ移動する。
"""
import os
import shutil
import sys
import time

from note_auth_client import NoteAuthClient, CookieExpiredError
from note_draft import NoteDraft
from simple_md import convert
from frontmatter import parse, extract_title, strip_title_heading
from validate import validate

SOURCE_DIR = "posts"
DONE_DIR = "posts_done"
SLEEP_SEC = 3.0
MAX_PER_RUN = 8
MIN_TEXT_LENGTH = 200


def process_file(path: str) -> dict:
    """1ファイルを読み込んで、投稿用のデータに変換する"""
    with open(path, encoding="utf-8") as f:
        content = f.read()

    meta, body = parse(content)

    fallback = os.path.splitext(os.path.basename(path))[0]
    title = extract_title(meta, body, fallback)
    body = strip_title_heading(body)

    html = convert(body)
    result = validate(html, verbose=False)

    return {
        "title": title,
        "html": html,
        "meta": meta,
        "validation": result,
    }


def main(dry_run: bool = False):
    if not os.path.isdir(SOURCE_DIR):
        print(f"{SOURCE_DIR}/ を作成して、Markdownを置いてください")
        return

    files = sorted(
        f for f in os.listdir(SOURCE_DIR) if f.endswith(".md")
    )
    if not files:
        print("処理対象のファイルがありません")
        return

    print(f"対象: {len(files)} ファイル"
          f"{'（確認のみ）' if dry_run else ''}\n")

    client = None
    draft = None

    if not dry_run:
        try:
            client = NoteAuthClient()
            client.verify()
            draft = NoteDraft(client)
        except CookieExpiredError as e:
            print("認証エラー:", e)
            return
        os.makedirs(DONE_DIR, exist_ok=True)

    created = 0

    for filename in files[:MAX_PER_RUN]:
        path = os.path.join(SOURCE_DIR, filename)
        print(f"--- {filename}")

        try:
            data = process_file(path)
        except Exception as e:
            print(f"  読み込みエラー: {e}")
            continue

        v = data["validation"]
        print(f"  タイトル: {data['title'][:44]}")
        print(f"  本文    : {v['text_length']:,} 文字")

        if v["warnings"]:
            for w in v["warnings"]:
                print(f"  警告: {w}")

        if v["text_length"] < MIN_TEXT_LENGTH:
            print(f"  スキップ: 本文が短すぎます")
            continue

        if dry_run:
            continue

        # 重複チェック
        if draft.find_by_title(data["title"]):
            print("  スキップ: 同名の下書きが既にあります")
            continue

        try:
            result = draft.create(data["title"], data["html"])
            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)

    if dry_run:
        print("\n確認のみで終了しました。"
              "実際に作成するには --run を付けてください")
    else:
        print(f"\n完了: {created} 件の下書きを作成しました")


if __name__ == "__main__":
    # 既定は確認のみ。--run を付けたときだけ実際に作成する
    main(dry_run="--run" not in sys.argv)

"""
Markdown変換の前後を比較して、失われた情報を検出する。

    python diff_check.py article.md

- 元の原稿と変換後のテキストを行単位で比較
- 消えた要素を警告として表示
"""
import difflib
import re
import sys

from simple_md import convert
from frontmatter import parse, strip_title_heading
from validate import validate


def html_to_plain(html: str) -> str:
    """変換後のHTMLからテキストだけを取り出す"""
    text = re.sub(r"<br\s*/?>", "\n", html)
    text = re.sub(r"</(p|h2|h3|li|blockquote)>", "\n", text)
    text = re.sub(r"<li>", "- ", text)
    text = re.sub(r"<[^>]+>", "", text)

    # HTMLエンティティを戻す
    for entity, char in [
        ("&lt;", "<"), ("&gt;", ">"),
        ("&quot;", '"'), ("&amp;", "&"),
    ]:
        text = text.replace(entity, char)

    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()


def md_to_plain(md: str) -> str:
    """元の原稿からも記法を落として比較用にする"""
    text = md

    text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)
    text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)
    text = re.sub(r"\*([^*]+)\*", r"\1", text)
    text = re.sub(r"~~([^~]+)~~", r"\1", text)
    text = re.sub(r"`([^`]+)`", r"\1", text)
    text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text)
    text = re.sub(r"^>\s*", "", text, flags=re.MULTILINE)
    text = re.sub(r"^[-*+]\s+", "- ", text, flags=re.MULTILINE)
    text = re.sub(r"^(-{3,}|\*{3,})$", "", text, flags=re.MULTILINE)

    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()


def show_diff(original: str, converted: str, context: int = 1):
    """行単位の差分を表示する"""
    before = md_to_plain(original).split("\n")
    after = html_to_plain(converted).split("\n")

    diff = difflib.unified_diff(
        before, after,
        fromfile="元の原稿", tofile="変換後",
        lineterm="", n=context,
    )

    lines = list(diff)

    if len(lines) <= 2:
        print("  内容の差分はありません")
        return

    print("=== 差分 ===")
    for line in lines[:80]:
        if line.startswith("-") and not line.startswith("---"):
            print(f"  消えた: {line[1:][:64]}")
        elif line.startswith("+") and not line.startswith("+++"):
            print(f"  増えた: {line[1:][:64]}")


def count_elements(md: str) -> dict:
    """原稿内の要素数を数える"""
    return {
        "見出し": len(re.findall(r"^#{1,6}\s", md, re.MULTILINE)),
        "リスト項目": len(re.findall(r"^[-*+]\s", md, re.MULTILINE)),
        "番号リスト": len(re.findall(r"^\d+\.\s", md, re.MULTILINE)),
        "引用": len(re.findall(r"^>", md, re.MULTILINE)),
        "リンク": len(re.findall(r"\[[^\]]+\]\([^)]+\)", md)),
        "画像": len(re.findall(r"!\[[^\]]*\]\([^)]+\)", md)),
        "表の行": len(re.findall(r"^\|", md, re.MULTILINE)),
        "コードブロック": md.count("```") // 2,
    }


def main(path: str):
    with open(path, encoding="utf-8") as f:
        content = f.read()

    _, body = parse(content)
    body = strip_title_heading(body)

    html = convert(body)

    print("=== 原稿の要素 ===")
    for label, count in count_elements(body).items():
        if count:
            print(f"  {label}: {count}")

    print()
    validate(html)

    print()
    show_diff(body, html)

    print(f"\n=== 文字数 ===")
    print(f"  原稿   : {len(md_to_plain(body))} 文字")
    print(f"  変換後 : {len(html_to_plain(html))} 文字")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("使い方: python diff_check.py article.md")
        sys.exit(1)

    main(sys.argv[1])