md2plain 0.1.0__py3-none-any.whl

md2plain/__init__.py

@@ -0,0 +1,3 @@
+"""Convert Markdown into plain-text email."""
+
+__version__ = "0.1.0"

md2plain/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

md2plain/cli.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Convert Markdown to a plain-text email and copy it to the macOS clipboard.
+
+Only text/plain is placed on the clipboard, so pasting into Gmail's
+"Plain text mode" produces a real text/plain message.
+
+Usage:
+    md2plain note.md
+    md2plain note.md --width 72
+    md2plain note.md --watch
+    md2plain note.md --print
+    md2plain note.md -o out.txt
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+from . import __version__
+from .render import render_plain
+
+
+def positive_width(value: str) -> int:
+    width = int(value)
+    if width < 1:
+        raise argparse.ArgumentTypeError("width must be at least 1")
+    return width
+
+
+def read_input(path: str) -> str:
+    if path == "-":
+        return sys.stdin.read()
+    try:
+        return Path(path).read_text(encoding="utf-8-sig", errors="replace")
+    except FileNotFoundError:
+        sys.exit(f"File not found: {path}")
+    except OSError as exc:
+        sys.exit(f"Cannot read {path}: {exc}")
+
+
+def copy_text(text: str) -> None:
+    """Write plain text only, so Gmail's plain-text mode gets it verbatim."""
+    from AppKit import NSPasteboard, NSPasteboardTypeString
+
+    name = os.environ.get("MD2PLAIN_PASTEBOARD", "general")
+    board = (
+        NSPasteboard.generalPasteboard()
+        if name == "general"
+        else NSPasteboard.pasteboardWithName_(name)
+    )
+    board.clearContents()
+    board.declareTypes_owner_([NSPasteboardTypeString], None)
+    board.setString_forType_(text, NSPasteboardTypeString)
+
+
+def finish(text: str, args: argparse.Namespace) -> None:
+    if args.output:
+        Path(args.output).write_text(text, encoding="utf-8")
+    if args.show:
+        sys.stdout.write(text)
+    if args.no_copy:
+        return
+
+    try:
+        copy_text(text)
+    except ImportError:
+        sys.exit("pyobjc is not installed; use --print or -o instead")
+
+    print(
+        f"Copied {len(text.splitlines())} lines / {len(text)} chars of plain text. "
+        "Enable Gmail's Plain text mode, then press Cmd+V.",
+        file=sys.stderr,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        prog="md2plain",
+        description="Convert Markdown to plain-text email and copy it to the clipboard.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument("input", help="Markdown file, or - for stdin")
+    parser.add_argument("-o", "--output", help="also write the plain text to a file")
+    parser.add_argument(
+        "--print", dest="show", action="store_true", help="write to stdout"
+    )
+    parser.add_argument(
+        "--no-copy", action="store_true", help="do not touch the clipboard"
+    )
+    parser.add_argument(
+        "--watch", action="store_true", help="update the clipboard on save"
+    )
+    parser.add_argument(
+        "--width", type=positive_width, default=75, help="line width (default: 75)"
+    )
+    parser.add_argument(
+        "--soft-breaks",
+        action="store_true",
+        help="treat a single newline as a space (default: keep line breaks)",
+    )
+    args = parser.parse_args()
+
+    if args.watch and args.input == "-":
+        parser.error("--watch requires a file, not stdin")
+
+    text = read_input(args.input)
+    if not text.strip():
+        sys.exit("Input is empty.")
+
+    preserve_breaks = not args.soft_breaks
+
+    def convert(src: str) -> None:
+        finish(render_plain(src, args.width, preserve_breaks), args)
+
+    if not args.watch:
+        convert(text)
+        return 0
+
+    last_mtime: float | None = None
+    try:
+        while True:
+            try:
+                mtime = os.stat(args.input).st_mtime
+            except FileNotFoundError:
+                time.sleep(1)
+                continue
+            if mtime != last_mtime:
+                convert(read_input(args.input))
+                last_mtime = mtime
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopped watching.", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

md2plain/render.py

@@ -0,0 +1,280 @@
+"""Render Markdown as plain-text email in reStructuredText style.
+
+Headings use = / - / ~ underlines, paragraphs are hard-wrapped at 75
+columns (CJK counts as two), lists use "*", quotes use ">", and code is
+indented by four spaces.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+from markdown_it import MarkdownIt
+from markdown_it.tree import SyntaxTreeNode
+
+UNDERLINE = {1: "=", 2: "-", 3: "~", 4: "^", 5: '"', 6: "'"}
+QUOTE = ">"
+
+# Punctuation that must not start a line (CJK line-breaking rule).
+NO_LINE_START = set("。，、；：！？）〕］｝》」』】’”…·%,.;:!?)]}'\"")
+# Link schemes that are safe to keep.
+SAFE_LINK = re.compile(r"^(https?://|mailto:|#)", re.IGNORECASE)
+
+
+def char_width(ch: str) -> int:
+    """Display width of one character: 2 for wide (CJK) characters."""
+    return 2 if unicodedata.east_asian_width(ch) in "WF" else 1
+
+
+def disp_width(text: str) -> int:
+    return sum(char_width(c) for c in text)
+
+
+# --------------------------------------------------------------------- inline
+
+
+def inline_text(node: SyntaxTreeNode, with_urls: bool = True) -> str:
+    """Flatten an inline node to text; links become "label (url)"."""
+    kind = node.type
+
+    if kind in ("text", "code_inline"):
+        return node.content
+    if kind == "softbreak":
+        return " "
+    if kind == "hardbreak":
+        return "\n"
+    if kind == "image":
+        return node.content or (node.attrs.get("src") or "")
+    if kind == "html_inline":
+        return ""
+    if kind == "link":
+        label = "".join(inline_text(c, False) for c in node.children)
+        href = node.attrs.get("href") or ""
+        if not with_urls or not href or not SAFE_LINK.match(href):
+            return label
+        # Do not repeat a bare address: mailto:a@b.com with label a@b.com.
+        if href.lower().startswith("mailto:") and href[7:] == label:
+            return label
+        # A URL used as its own label needs no "(url)" suffix, even when the
+        # target only differs by tracking parameters.
+        if label.startswith(("http://", "https://")):
+            base = href.split("?", 1)[0].split("#", 1)[0].rstrip("/")
+            if base == label.rstrip("/"):
+                return label
+        if href != label:
+            return f"{label} ({href})"
+        return label
+
+    return "".join(inline_text(c, with_urls) for c in node.children)
+
+
+def plain_of(node: SyntaxTreeNode) -> str:
+    return inline_text(node, with_urls=False)
+
+
+# ----------------------------------------------------------------------- wrap
+
+
+def wrap_line(line: str, width: int) -> list[str]:
+    """Wrap one line at spaces, breaking CJK text between characters."""
+    line = re.sub(r"[ \t]+", " ", line).strip()
+    if not line:
+        return [""]
+
+    out: list[str] = []
+    current: list[str] = []
+    current_width = 0
+    last_space = -1
+
+    for ch in line:
+        w = char_width(ch)
+        if current and current_width + w > width:
+            if ch in NO_LINE_START:
+                current.append(ch)
+                current_width += w
+                continue
+
+            if last_space > 0:
+                out.append("".join(current[:last_space]).rstrip())
+                current = current[last_space + 1 :]
+            else:
+                out.append("".join(current).rstrip())
+                current = []
+
+            current_width = sum(char_width(c) for c in current)
+            last_space = -1
+            for i, c in enumerate(current):
+                if c == " ":
+                    last_space = i
+
+        current.append(ch)
+        current_width += w
+        if ch == " ":
+            last_space = len(current) - 1
+
+    if current:
+        out.append("".join(current).rstrip())
+    # Very small widths can produce blank lines; keep the result non-empty.
+    return [line for line in out if line] or [""]
+
+
+def wrap_text(text: str, width: int) -> list[str]:
+    lines: list[str] = []
+    for part in text.split("\n"):
+        lines.extend(wrap_line(part, width))
+    return lines
+
+
+# --------------------------------------------------------------------- blocks
+
+
+def render_blocks(nodes: list[SyntaxTreeNode], width: int) -> list[str]:
+    out: list[str] = []
+
+    for node in nodes:
+        kind = node.type
+
+        if kind == "heading":
+            level = int(node.tag[1])
+            text = plain_of(node.children[0]).strip()
+            if not text:
+                continue
+            mark = UNDERLINE.get(level, "-")
+            out += [text, mark * max(disp_width(text), 3), ""]
+
+        elif kind == "paragraph":
+            out += wrap_text(inline_text(node.children[0]), width)
+            out.append("")
+
+        elif kind in ("bullet_list", "ordered_list"):
+            out += render_list(node, width)
+
+        elif kind == "blockquote":
+            body = render_blocks(node.children, width - 2)
+            while body and not body[-1]:
+                body.pop()
+            out += [QUOTE if not line else f"{QUOTE} {line}" for line in body]
+            out.append("")
+
+        elif kind in ("fence", "code_block"):
+            code = (node.content or "").rstrip("\n").split("\n")
+            out += ["    " + line for line in code]
+            out.append("")
+
+        elif kind == "hr":
+            out += ["-" * min(width, 72), ""]
+
+        elif kind == "table":
+            out += render_table(node, width)
+            out.append("")
+
+        elif kind == "html_block":
+            continue
+
+        elif node.children:
+            out += render_blocks(node.children, width)
+
+    return out
+
+
+def render_list(node: SyntaxTreeNode, width: int) -> list[str]:
+    ordered = node.type == "ordered_list"
+    start = int(node.attrs.get("start", 1)) if ordered else None
+    out: list[str] = []
+
+    for i, item in enumerate(node.children):
+        marker = f"{start + i}. " if start is not None else "* "
+        body = render_blocks(item.children, width - len(marker))
+        while body and not body[-1]:
+            body.pop()
+
+        # Keep nested lists tight: drop the blank line before them.
+        tight: list[str] = []
+        for k, line in enumerate(body):
+            if not line:
+                nxt = k + 1
+                while nxt < len(body) and not body[nxt]:
+                    nxt += 1
+                if nxt < len(body) and re.match(r"^(\* |\d+\. )", body[nxt]):
+                    continue
+            tight.append(line)
+
+        for j, line in enumerate(tight):
+            out.append((marker if j == 0 else " " * len(marker)) + line)
+
+    out.append("")
+    return out
+
+
+def render_table(node: SyntaxTreeNode, width: int) -> list[str]:
+    rows: list[list[str]] = []
+    for section in node.children:
+        for tr in section.children:
+            cells = [
+                "".join(plain_of(c) for c in cell.children).strip()
+                for cell in tr.children
+            ]
+            if cells:
+                rows.append(cells)
+    if not rows:
+        return []
+
+    ncols = max(len(row) for row in rows)
+    for row in rows:
+        row.extend([""] * (ncols - len(row)))
+
+    widths = [max(disp_width(row[c]) for row in rows) for c in range(ncols)]
+    while sum(widths) + 2 * (ncols - 1) > width and max(widths) > 4:
+        widths[widths.index(max(widths))] -= 1
+
+    def fmt(row: list[str]) -> str:
+        padded = []
+        for c, cell in enumerate(row):
+            padded.append(cell + " " * max(widths[c] - disp_width(cell), 0))
+        return "  ".join(padded).rstrip()
+
+    lines = [fmt(rows[0]), "  ".join("-" * w for w in widths)]
+    lines += [fmt(row) for row in rows[1:]]
+    return lines
+
+
+# --------------------------------------------------------------------- output
+
+
+def parse(md_text: str, preserve_breaks: bool = True) -> SyntaxTreeNode:
+    md = MarkdownIt(
+        "commonmark", {"html": False, "linkify": True, "typographer": False}
+    )
+    md.enable(["table", "strikethrough", "linkify"])
+    tokens = md.parse(md_text)
+
+    if preserve_breaks:
+        # A single newline usually means a real line break here (signatures,
+        # dates), unlike CommonMark's default of joining it with a space.
+        for token in tokens:
+            if token.type == "inline" and token.children:
+                for child in token.children:
+                    if child.type == "softbreak":
+                        child.type = "hardbreak"
+
+    return SyntaxTreeNode(tokens)
+
+
+def tidy(lines: list[str]) -> list[str]:
+    out: list[str] = []
+    for line in lines:
+        line = line.rstrip()
+        if not line and out and not out[-1]:
+            continue
+        out.append(line)
+    while out and not out[0]:
+        out.pop(0)
+    while out and not out[-1]:
+        out.pop()
+    return out
+
+
+def render_plain(md_text: str, width: int = 75, preserve_breaks: bool = True) -> str:
+    lines = tidy(render_blocks(parse(md_text, preserve_breaks).children, width))
+    return "\n".join(lines) + "\n"

md2plain-0.1.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.5
+Name: md2plain
+Version: 0.1.0
+Summary: Convert Markdown to plain-text email for Gmail's Plain text mode.
+Project-URL: Homepage, https://github.com/hoshF/md2plain
+Project-URL: Issues, https://github.com/hoshF/md2plain/issues
+Author-email: hoshF <noveor.ol@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 hoshF
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: cli,email,gmail,markdown,plain-text
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.10
+Requires-Dist: linkify-it-py>=2.0
+Requires-Dist: markdown-it-py>=3.0
+Requires-Dist: pyobjc-framework-cocoa>=10.0; sys_platform == 'darwin'
+Provides-Extra: dev
+Requires-Dist: black>=24; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# md2plain
+
+[![CI](https://github.com/hoshF/md2plain/actions/workflows/ci.yml/badge.svg)](https://github.com/hoshF/md2plain/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](pyproject.toml)
+[![Platform: macOS](https://img.shields.io/badge/platform-macOS-lightgrey)](pyproject.toml)
+
+**Markdown in, plain-text email out.**
+
+`md2plain` renders Markdown as a plain-text email and copies it to the macOS
+clipboard as `text/plain`. Paste it into Gmail's **Plain text mode** and the
+message is sent as a real `text/plain` message: hard-wrapped, with no HTML,
+no fonts, and no client-side reflow.
+
+## Demo
+
+Input:
+
+```markdown
+# Quarterly Update
+
+This is a **short** note with a [link](https://example.com).
+
+* one
+* two
+
+> quoted
+```
+
+Output:
+
+```text
+Quarterly Update
+================
+
+This is a short note with a link (https://example.com).
+
+* one
+* two
+
+> quoted
+```
+
+## Why
+
+- Gmail's normal compose always sends HTML, even when you paste plain text.
+- Rich text copied from Typora carries its own CSS, which mail clients mangle.
+- Plain text has no automatic reflow, so the sender has to control line width.
+- A 75-column limit leaves room for `> ` quote prefixes and stays within
+  RFC 5322's recommended 78 characters.
+
+## Requirements
+
+- macOS (the clipboard is written through AppKit)
+- Python 3.10 or newer
+
+## Install
+
+With [pipx](https://pipx.pypa.io/):
+
+```bash
+pipx install .
+```
+
+Or from a checkout, in a virtual environment:
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e .
+```
+
+## Usage
+
+```bash
+md2plain note.md
+```
+
+Then in Gmail: open the compose window, click the three-dot menu, choose
+**Plain text mode**, and press `Cmd+V`.
+
+To verify, send a message to yourself and use **Show original**. The message
+should contain only:
+
+```text
+Content-Type: text/plain; charset="UTF-8"
+```
+
+No `multipart/alternative`, no `text/html`.
+
+## Options
+
+| Option | Description |
+|---|---|
+| `--width N` | Line width in columns (default: 75) |
+| `--watch` | Update the clipboard whenever the file is saved |
+| `--print` | Write to stdout instead of the clipboard |
+| `-o, --output FILE` | Also write the plain text to a file |
+| `--soft-breaks` | Treat single newlines as spaces |
+| `--version` | Print the version and exit |
+
+## Output format
+
+| Markdown | Output |
+|---|---|
+| `# Heading` | heading + `====` underline |
+| `## Heading` | heading + `----` underline |
+| `### Heading` | heading + `~~~~` underline |
+| Paragraph | hard-wrapped at 75 columns (CJK counts as two) |
+| `- item` | `* item`, with hanging indent |
+| `1. item` | `1. item` |
+| `> quote` | `> quote` |
+| Code block | indented by four spaces |
+| `[text](url)` | `text (url)` |
+| Table | column-aligned plain text |
+| Single newline | kept (signatures and dates stay on their own lines) |
+
+## How it works
+
+1. `markdown-it-py` parses CommonMark plus tables, strikethrough, and
+   autolinks.
+2. `src/md2plain/render.py` wraps text by display width (CJK counts as two
+   columns), renders headings, lists, quotes, and tables.
+3. `src/md2plain/cli.py` reads UTF-8 (BOM tolerant) and writes exactly one
+   clipboard type: `text/plain`.
+
+## Limitations
+
+- macOS only; the clipboard backend is AppKit.
+- Plain text has no bold, italics, or clickable links. Link URLs are kept as
+  text, and links inside headings or table cells lose the URL.
+- Images become alt text. YAML front matter, footnotes, math, and Mermaid
+  diagrams are not converted.
+- Tables are aligned with spaces, so proportional fonts break the alignment.
+- Gmail may collapse `>` quote blocks behind a three-dot control; this is
+  display only and the content stays intact.
+
+## Development
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e ".[dev]"
+.venv/bin/python -m unittest discover -s tests -v
+.venv/bin/ruff check src tests
+.venv/bin/black --check src tests
+```
+
+The `./md2plain` script in the repository root is a development launcher; it
+runs the package from `.venv`. Installed users get the `md2plain` command from
+`pyproject.toml`.
+
+## License
+
+[MIT](LICENSE). See [CHANGELOG.md](CHANGELOG.md) for release history.

md2plain-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+md2plain/__init__.py,sha256=cf1lnlvj00XKs2SZvzGpZeoYCKmNbgW7EBzgzasGNrQ,69
+md2plain/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+md2plain/cli.py,sha256=cafYGn2QUUGTWZuiaeORxaAY8EAyiS6EsXizAIczPgM,4115
+md2plain/render.py,sha256=MBOcaIn93exuHtlYnokwertziBERQF0QdNhq0b9lTlI,8925
+md2plain-0.1.0.dist-info/METADATA,sha256=PByUSBWwq-jKCrCpGJoEDm0i6XzWwEjDzVw8YYHVo3Q,6505
+md2plain-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+md2plain-0.1.0.dist-info/entry_points.txt,sha256=I92mxKS_-_eLAu5PleHXkvN46RkSuCHK8Fkj2NgPeKM,47
+md2plain-0.1.0.dist-info/licenses/LICENSE,sha256=yz5qS2XkiEU3inW-ky4zpr1M2rXdnhxI8NkMPBgFsoM,1062
+md2plain-0.1.0.dist-info/RECORD,,

md2plain-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

md2plain-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+md2plain = md2plain.cli:main

md2plain-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hoshF
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.