python-substack 0.1.22__tar.gz → 0.1.24__tar.gz

{python_substack-0.1.22 → python_substack-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-substack
-Version: 0.1.22
+Version: 0.1.24
 Summary: A Python wrapper around the Substack API.
 License: MIT
 License-File: LICENSE
@@ -16,6 +16,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: PyYAML (>=6.0,<7.0)
+Requires-Dist: markdown-it-py (>=3.0,<4.0)
+Requires-Dist: mdit-py-plugins (>=0.4,<0.5)
 Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
 Requires-Dist: requests (>=2.32.0,<3.0.0)
 Project-URL: Homepage, https://github.com/ma2za/python-substack
@@ -180,6 +182,22 @@ This is a paragraph with **bold** and *italic* text.
 """
 post.from_markdown(markdown_content, api=api)
 
+# Markdown footnotes are supported too. References become inline anchors and
+# definitions become footnote blocks, numbered by order of first appearance.
+# Labels can be numbers or names (e.g. [^1] or [^source]).
+footnote_markdown = """
+A claim that needs support.[^1] Another, with a named label.[^source]
+
+[^1]: The supporting detail, with a [link](https://example.com).
+[^source]: Author, *Title* (2025).
+"""
+post.from_markdown(footnote_markdown, api=api)
+
+# Or build footnotes manually:
+post.paragraph(content=[{"content": "Some claim."}]).footnote_anchor(1)
+post.footnote(1, "The note text, with **formatting** allowed.")
+
+
 draft = api.post_draft(post.get_draft())
 
 # set section (can only be done after first posting the draft)

{python_substack-0.1.22 → python_substack-0.1.24}/README.md

@@ -156,6 +156,22 @@ This is a paragraph with **bold** and *italic* text.
 """
 post.from_markdown(markdown_content, api=api)
 
+# Markdown footnotes are supported too. References become inline anchors and
+# definitions become footnote blocks, numbered by order of first appearance.
+# Labels can be numbers or names (e.g. [^1] or [^source]).
+footnote_markdown = """
+A claim that needs support.[^1] Another, with a named label.[^source]
+
+[^1]: The supporting detail, with a [link](https://example.com).
+[^source]: Author, *Title* (2025).
+"""
+post.from_markdown(footnote_markdown, api=api)
+
+# Or build footnotes manually:
+post.paragraph(content=[{"content": "Some claim."}]).footnote_anchor(1)
+post.footnote(1, "The note text, with **formatting** allowed.")
+
+
 draft = api.post_draft(post.get_draft())
 
 # set section (can only be done after first posting the draft)

{python_substack-0.1.22 → python_substack-0.1.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-substack"
-version = "0.1.22"
+version = "0.1.24"
 description = "A Python wrapper around the Substack API."
 authors = ["Paolo Mazza <mazzapaolo2019@gmail.com>"]
 license = "MIT"
@@ -21,6 +21,8 @@ python = "<4.0,>=3.10"
 requests = "^2.32.0"
 python-dotenv = "^1.2.1"
 PyYAML = "^6.0"
+markdown-it-py = "^3.0"
+mdit-py-plugins = "^0.4"
 
 [tool.poetry.group.dev.dependencies]
 

{python_substack-0.1.22 → python_substack-0.1.24}/substack/__init__.py

@@ -3,7 +3,7 @@
 __author__ = "Paolo Mazza"
 __email__ = "mazzapaolo2019@gmail.com"
 __license__ = "MIT License"
-__version__ = "0.1.21"
+__version__ = "0.1.24"
 __url__ = "https://github.com/ma2za/python-substack"
 __download_url__ = "https://pypi.python.org/pypi/python-substack"
 __description__ = "A Python wrapper around the Substack API"

python_substack-0.1.24/substack/mdrender.py

@@ -0,0 +1,210 @@
+"""Markdown -> Substack ProseMirror via markdown-it-py.
+
+Implements Post.from_markdown() using a real CommonMark parser (markdown-it-py)
+plus the standard footnote plugin, with a small renderer that walks the syntax
+tree into Substack's node schema.
+
+Node construction goes through ``substack.nodes`` so the (undocumented) schema
+lives in exactly one place.
+
+Footnotes: Substack numbers footnote anchors by their position in the document
+and pairs them one-to-one, in order, with the footnote blocks at the end (it
+ignores any explicit number and does not support one block serving several
+anchors). So each reference is emitted as its own sequentially-numbered anchor,
+and a matching footnote block is appended for each -- a definition referenced
+more than once is duplicated, which mirrors how Substack's own editor behaves.
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Dict, List, Optional
+
+from markdown_it import MarkdownIt
+from markdown_it.tree import SyntaxTreeNode
+from mdit_py_plugins.footnote import footnote_plugin
+
+from substack import nodes
+from substack.nodes import MarkType, NodeType
+
+_MARK_FOR = {
+    "strong": {"type": MarkType.STRONG},
+    "em": {"type": MarkType.EM},
+    "s": {"type": MarkType.STRIKETHROUGH},
+}
+
+
+def _make_parser() -> MarkdownIt:
+    return MarkdownIt("commonmark").use(footnote_plugin).enable("strikethrough")
+
+
+def _coalesce(out_nodes: List[Dict]) -> List[Dict]:
+    """Merge adjacent text nodes that carry identical marks (e.g. softbreaks)."""
+    merged: List[Dict] = []
+    for node in out_nodes:
+        if (
+            merged
+            and node.get("type") == NodeType.TEXT
+            and merged[-1].get("type") == NodeType.TEXT
+            and node.get("marks") == merged[-1].get("marks")
+        ):
+            merged[-1]["text"] += node["text"]
+        else:
+            merged.append(node)
+    return merged
+
+
+def _render_inline(node: SyntaxTreeNode, marks: List[Dict], ctx: Dict) -> List[Dict]:
+    """Render an inline subtree into a flat list of text / anchor nodes."""
+    out: List[Dict] = []
+    for child in node.children:
+        t = child.type
+        if t == "text":
+            if child.content:
+                out.append(nodes.text(child.content, marks))
+        elif t == "code_inline":
+            out.append(nodes.text(child.content, marks + [nodes.code_mark()]))
+        elif t in _MARK_FOR:
+            out.extend(_render_inline(child, marks + [_MARK_FOR[t]], ctx))
+        elif t == "link":
+            href = child.attrs.get("href", "")
+            out.extend(_render_inline(child, marks + [nodes.link_mark(href)], ctx))
+        elif t in ("softbreak", "hardbreak"):
+            out.append(nodes.text(" ", marks))
+        elif t == "footnote_ref":
+            # Number anchors by document position and record which definition each
+            # one points to, so matching blocks can be emitted 1:1 afterwards.
+            ctx["order"].append(child.meta["id"])
+            out.append(nodes.footnote_anchor(len(ctx["order"])))
+        elif t == "image":
+            # Inline images are rare in this schema; fall back to alt text.
+            alt = child.attrs.get("alt") or "".join(
+                c.content for c in child.children if c.type == "text"
+            )
+            if alt:
+                out.append(nodes.text(alt, marks))
+    return _coalesce(out)
+
+
+def _only_image(inline: SyntaxTreeNode) -> Optional[SyntaxTreeNode]:
+    """If an inline node is just an image (optionally wrapped in a link), return it."""
+    kids = [c for c in inline.children if c.type != "softbreak"]
+    if len(kids) == 1 and kids[0].type == "image":
+        return kids[0]
+    if len(kids) == 1 and kids[0].type == "link":
+        inner = [c for c in kids[0].children if c.type != "softbreak"]
+        if len(inner) == 1 and inner[0].type == "image":
+            img = inner[0]
+            img._link_href = kids[0].attrs.get("href")  # type: ignore[attr-defined]
+            return img
+    return None
+
+
+def _captioned_image(img: SyntaxTreeNode, api) -> Dict:
+    src = img.attrs.get("src", "")
+    if src.startswith("/"):
+        src = src[1:]
+    if api is not None and not src.startswith("http"):
+        try:
+            src = api.get_image(src).get("url")
+        except Exception:
+            pass
+    # markdown-it stores the image alt text as the node's content, not in attrs.
+    alt = img.content or img.attrs.get("alt") or None
+    # Standard markdown image title `![alt](src "caption")` maps to Substack's caption node.
+    title = img.attrs.get("title") or None
+    caption = [nodes.text(title)] if title else None
+    return nodes.captioned_image(
+        src,
+        alt=alt,
+        href=getattr(img, "_link_href", None),
+        caption=caption,
+    )
+
+
+def _render_block(node: SyntaxTreeNode, api, ctx: Dict) -> List[Dict]:
+    """Render a block-level node into zero or more Substack nodes."""
+    t = node.type
+
+    if t == "paragraph":
+        inline = node.children[0]
+        img = _only_image(inline)
+        if img is not None:
+            return [_captioned_image(img, api)]
+        return [nodes.paragraph(_render_inline(inline, [], ctx))]
+
+    if t == "heading":
+        level = int(node.tag[1])
+        return [nodes.heading(_render_inline(node.children[0], [], ctx), level=level)]
+
+    if t == "hr":
+        return [nodes.horizontal_rule()]
+
+    if t in ("fence", "code_block"):
+        return [
+            nodes.code_block(
+                node.content.rstrip("\n"), language=node.info.strip() or None
+            )
+        ]
+
+    if t == "blockquote":
+        paras: List[Dict] = []
+        for child in node.children:
+            paras.extend(_render_block(child, api, ctx))
+        return [nodes.blockquote(paras)]
+
+    if t == "bullet_list":
+        return [nodes.bullet_list(_render_list_items(node, api, ctx))]
+
+    if t == "ordered_list":
+        return [nodes.ordered_list(_render_list_items(node, api, ctx))]
+
+    # footnote_block is handled separately in markdown_to_doc; ignore it here.
+    return []
+
+
+def _render_list_items(list_node: SyntaxTreeNode, api, ctx: Dict) -> List[Dict]:
+    items = []
+    for li in list_node.children:
+        content: List[Dict] = []
+        for child in li.children:
+            content.extend(_render_block(child, api, ctx))
+        items.append({"type": NodeType.LIST_ITEM, "content": content})
+    return items
+
+
+def _footnote_definitions(tree: SyntaxTreeNode, api) -> Dict[int, List[Dict]]:
+    """Map each footnote id to its rendered block content."""
+    definitions: Dict[int, List[Dict]] = {}
+    for node in tree.children:
+        if node.type != "footnote_block":
+            continue
+        for fn in node.children:
+            # A footnote's own content should not register anchors of its own.
+            local_ctx = {"order": []}
+            content: List[Dict] = []
+            for child in fn.children:
+                content.extend(_render_block(child, api, local_ctx))
+            definitions[fn.meta["id"]] = content
+    return definitions
+
+
+def markdown_to_doc(markdown_content: str, api=None) -> List[Dict]:
+    """Convert Markdown into a list of Substack ProseMirror block nodes."""
+    tree = SyntaxTreeNode(_make_parser().parse(markdown_content))
+
+    definitions = _footnote_definitions(tree, api)
+
+    ctx: Dict = {"order": []}
+    out: List[Dict] = []
+    for node in tree.children:
+        if node.type == "footnote_block":
+            continue
+        out.extend(_render_block(node, api, ctx))
+
+    # Emit one footnote block per reference, in anchor order, numbered to match.
+    for number, footnote_id in enumerate(ctx["order"], start=1):
+        content = copy.deepcopy(definitions.get(footnote_id, []))
+        out.append(nodes.footnote(number, content))
+
+    return out

python_substack-0.1.24/substack/nodes.py

@@ -0,0 +1,148 @@
+"""ProseMirror node builders for Substack documents.
+
+Centralises the (undocumented) Substack ProseMirror schema in one place.
+The node-type strings ("paragraph", "footnoteAnchor", "image2", ...) and
+their shapes live here rather than as inline dict literals scattered across
+post.py, giving:
+
+  * one source of truth for node shapes (so a schema change is a one-line fix),
+  * discoverable, typed constructors instead of bare dict literals,
+  * a natural seam for validation.
+
+The builders intentionally return plain dicts so they stay 100% compatible with
+the existing draft_body structure.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+
+class NodeType:
+    DOC = "doc"
+    PARAGRAPH = "paragraph"
+    HEADING = "heading"
+    TEXT = "text"
+    BLOCKQUOTE = "blockquote"
+    CODE_BLOCK = "codeBlock"
+    HORIZONTAL_RULE = "horizontal_rule"
+    BULLET_LIST = "bullet_list"
+    ORDERED_LIST = "ordered_list"
+    LIST_ITEM = "list_item"
+    FOOTNOTE = "footnote"
+    FOOTNOTE_ANCHOR = "footnoteAnchor"
+    CAPTIONED_IMAGE = "captionedImage"
+    CAPTION = "caption"
+
+
+class MarkType:
+    STRONG = "strong"
+    EM = "em"
+    CODE = "code"
+    STRIKETHROUGH = "strikethrough"
+    LINK = "link"
+
+
+def code_mark() -> Dict:
+    return {"type": MarkType.CODE}
+
+
+def text(value: str, marks: Optional[List[Dict]] = None) -> Dict:
+    node: Dict = {"type": NodeType.TEXT, "text": value}
+    if marks:
+        node["marks"] = marks
+    return node
+
+
+def link_mark(href: str) -> Dict:
+    return {"type": MarkType.LINK, "attrs": {"href": href}}
+
+
+def paragraph(content: Optional[List[Dict]] = None) -> Dict:
+    return {"type": NodeType.PARAGRAPH, "content": content or []}
+
+
+def heading(content: List[Dict], level: int = 1) -> Dict:
+    return {"type": NodeType.HEADING, "content": content, "attrs": {"level": level}}
+
+
+def horizontal_rule() -> Dict:
+    return {"type": NodeType.HORIZONTAL_RULE}
+
+
+def blockquote(paragraphs: List[Dict]) -> Dict:
+    node: Dict = {"type": NodeType.BLOCKQUOTE}
+    if paragraphs:
+        node["content"] = paragraphs
+    return node
+
+
+def list_item(content_nodes: List[Dict]) -> Dict:
+    return {
+        "type": NodeType.LIST_ITEM,
+        "content": [paragraph(content_nodes)],
+    }
+
+
+def bullet_list(items: List[Dict]) -> Dict:
+    return {"type": NodeType.BULLET_LIST, "content": items}
+
+
+def ordered_list(items: List[Dict]) -> Dict:
+    return {"type": NodeType.ORDERED_LIST, "content": items}
+
+
+def code_block(code: str, language: Optional[str] = None) -> Dict:
+    node: Dict = {"type": NodeType.CODE_BLOCK, "content": [text(code)]}
+    if language:
+        node["attrs"] = {"language": language}
+    return node
+
+
+def captioned_image(
+    src: str,
+    alt: Optional[str] = None,
+    href: Optional[str] = None,
+    caption: Optional[List[Dict]] = None,
+    image_size: str = "normal",
+) -> Dict:
+    content: List[Dict] = [
+        {
+            "type": "image2",
+            "attrs": {
+                "src": src,
+                "srcNoWatermark": None,
+                "fullscreen": False,
+                "imageSize": image_size,
+                "height": 819,
+                "width": 1456,
+                "resizeWidth": 728 if image_size == "normal" else None,
+                "bytes": None,
+                "alt": alt,
+                "title": None,
+                "type": None,
+                "href": href,
+                "belowTheFold": False,
+                "topImage": False,
+                "internalRedirect": None,
+                "isProcessing": False,
+                "align": None,
+                "offset": False,
+            },
+        }
+    ]
+    if caption:
+        content.append({"type": NodeType.CAPTION, "content": caption})
+    return {"type": NodeType.CAPTIONED_IMAGE, "content": content}
+
+
+def footnote_anchor(number: int) -> Dict:
+    return {"type": NodeType.FOOTNOTE_ANCHOR, "attrs": {"number": number}}
+
+
+def footnote(number: int, paragraphs: List[Dict]) -> Dict:
+    return {
+        "type": NodeType.FOOTNOTE,
+        "attrs": {"number": number},
+        "content": paragraphs or [paragraph()],
+    }

{python_substack-0.1.22 → python_substack-0.1.24}/substack/post.py

@@ -11,6 +11,7 @@ from typing import Dict, List
 __all__ = ["Post", "parse_inline", "tokens_to_text_nodes"]
 
 from substack.exceptions import SectionNotExistsException
+from substack import nodes
 
 
 def tokens_to_text_nodes(tokens: List[Dict]) -> List[Dict]:
@@ -543,6 +544,58 @@ class Post:
 
         return self
 
+    def footnote_anchor(self, number: int):
+        """
+
+        Add an inline footnote reference (the superscript marker) to the last block.
+
+        Args:
+            number: The footnote number this anchor points to.
+
+        Returns:
+            Self for method chaining.
+
+        """
+        content = self.draft_body["content"][-1].get("content", [])
+        content += [nodes.footnote_anchor(number)]
+        self.draft_body["content"][-1]["content"] = content
+        return self
+
+    def footnote(self, number: int, content=None):
+        """
+
+        Append a footnote block (the note shown at the foot of the post).
+
+        Args:
+            number: The footnote number, matching a footnote_anchor.
+            content: Text string or list of inline token dicts. A plain string is
+                parsed for inline Markdown and may contain blank-line-separated
+                paragraphs; a parse_inline() token list or a list of ready text
+                nodes is also accepted (single paragraph).
+
+        Returns:
+            Self for method chaining.
+
+        """
+        paragraphs: List[Dict] = []
+        if isinstance(content, str):
+            # Blank lines separate paragraphs within the footnote.
+            for chunk in re.split(r"\n\s*\n", content):
+                chunk = chunk.strip()
+                if chunk:
+                    paragraphs.append(nodes.paragraph(tokens_to_text_nodes(parse_inline(chunk))))
+        elif isinstance(content, list):
+            # Accept either parse_inline tokens ({"content": ...}) or text nodes.
+            if content and content[0].get("type") == "text":
+                text_nodes = content
+            else:
+                text_nodes = tokens_to_text_nodes(content)
+            paragraphs.append(nodes.paragraph(text_nodes))
+
+        node: Dict = nodes.footnote(number, paragraphs)
+        self.draft_body["content"] = self.draft_body.get("content", []) + [node]
+        return self
+
     def from_markdown(self, markdown_content: str, api=None):
         """
         Parse Markdown content and add it to the post.
@@ -559,6 +612,10 @@ class Post:
           - Ordered lists: Lines starting with '1.', '2.', etc.
           - Horizontal rules: Lines with ---, ***, or ___
           - Inline formatting: **bold**, *italic*, ***bold+italic***, `code`, ~~strikethrough~~
+          - Footnotes: ``text.[^label]`` references plus ``[^label]: definition``
+            lines. References become inline anchors and definitions become
+            footnote blocks, numbered by order of first appearance. Labels may be
+            numbers or names (e.g. ``[^1]`` or ``[^agi-book]``).
 
         Args:
             markdown_content: Markdown string to parse and add to the post.
@@ -572,276 +629,8 @@ class Post:
             >>> post = Post("Title", "Subtitle", user_id)
             >>> post.from_markdown("# Heading\\n\\nThis is **bold** text with [a link](https://example.com).")
         """
-        lines = markdown_content.split("\n")
-        blocks = []
-        current_block: List[str] = []
-        in_code_block = False
-        code_block_language = None
-
-        for line in lines:
-            # Check for fenced code block start/end
-            if line.strip().startswith("```"):
-                if in_code_block:
-                    # End of code block
-                    if current_block:
-                        blocks.append({
-                            "type": "code",
-                            "language": code_block_language,
-                            "content": "\n".join(current_block)
-                        })
-                    current_block = []
-                    in_code_block = False
-                    code_block_language = None
-                else:
-                    # Start of code block
-                    if current_block:
-                        blocks.append({"type": "text", "content": "\n".join(current_block)})
-                        current_block = []
-                    # Extract language if specified
-                    language = line.strip()[3:].strip()
-                    code_block_language = language if language else None
-                    in_code_block = True
-                continue
-
-            if in_code_block:
-                # Inside code block - collect lines as-is
-                current_block.append(line)
-            else:
-                # Regular content
-                if line.strip() == "":
-                    # Empty line - end current block if it has content
-                    if current_block:
-                        blocks.append({"type": "text", "content": "\n".join(current_block)})
-                        current_block = []
-                else:
-                    current_block.append(line)
-
-        # Add any remaining content
-        if current_block:
-            if in_code_block:
-                blocks.append({
-                    "type": "code",
-                    "language": code_block_language,
-                    "content": "\n".join(current_block)
-                })
-            else:
-                blocks.append({"type": "text", "content": "\n".join(current_block)})
-
-        # Process blocks
-        for block in blocks:
-            if block["type"] == "code":
-                # Add code block
-                code_content = block.get("content", "").strip()
-                if code_content:
-                    # Substack uses "codeBlock" type
-                    code_attrs = {}
-                    if block.get("language"):
-                        code_attrs["language"] = block["language"]
-                    self.add({
-                        "type": "codeBlock",
-                        "content": code_content,  # Pass as string, code_block method will handle it
-                        "attrs": code_attrs
-                    })
-            else:
-                # Process text block
-                text_content = block.get("content", "").strip()
-                if not text_content:
-                    continue
-
-                # Check for horizontal rule: ---, ***, ___
-                if re.match(r'^(\*{3,}|-{3,}|_{3,})\s*$', text_content):
-                    self.horizontal_rule()
-                    continue
-
-                # Process headings (lines starting with '#' characters)
-                if text_content.startswith("#"):
-                    level = len(text_content) - len(text_content.lstrip("#"))
-                    heading_text = text_content.lstrip("#").strip()
-                    if heading_text:  # Only add if there's actual text
-                        self.heading(content=heading_text, level=min(level, 6))
-
-                # Process images using Markdown image syntax: ![Alt](URL)
-                # Also handle linked images: [![Alt](image_url)](link_url)
-                elif text_content.startswith("!") or (text_content.startswith("[") and "![" in text_content):
-                    # Check for linked image first: [![alt](img)](link)
-                    linked_image_match = re.match(r'\[!\[([^\]]*)\]\(([^)]+)\)\]\(([^)]+)\)', text_content)
-                    if linked_image_match:
-                        # Linked image - create image with href
-                        alt_text = linked_image_match.group(1)
-                        image_url = linked_image_match.group(2)
-                        link_url = linked_image_match.group(3)
-
-                        # Adjust image URL if it starts with a slash
-                        image_url = image_url[1:] if image_url.startswith("/") else image_url
-
-                        # If api is provided and image_url is a local file, upload it
-                        if api is not None:
-                            try:
-                                image = api.get_image(image_url)
-                                image_url = image.get("url")
-                            except Exception:
-                                # If upload fails, use original URL
-                                pass
-
-                        self.add({
-                            "type": "captionedImage",
-                            "src": image_url,
-                            "alt": alt_text,
-                            "href": link_url
-                        })
-                    else:
-                        # Regular image: ![Alt](URL)
-                        match = re.match(r"!\[.*?\]\((.*?)\)", text_content)
-                        if match:
-                            image_url = match.group(1)
-                            # Adjust image URL if it starts with a slash
-                            image_url = image_url[1:] if image_url.startswith("/") else image_url
-
-                            # If api is provided and image_url is a local file, upload it
-                            if api is not None:
-                                try:
-                                    image = api.get_image(image_url)
-                                    image_url = image.get("url")
-                                except Exception:
-                                    # If upload fails, use original URL
-                                    pass
-
-                            self.add({"type": "captionedImage", "src": image_url})
-
-                # Process paragraphs, bullet lists, ordered lists, or blockquotes
-                else:
-                    if "\n" in text_content:
-                        # Process each line, grouping consecutive bullets/ordered items
-                        # into list nodes and consecutive blockquote lines into a
-                        # single blockquote node.
-                        pending_bullets: List[List[Dict]] = []
-                        pending_quotes: List[str] = []
-                        pending_ordered: List[List[Dict]] = []
-
-                        def flush_bullets():
-                            if not pending_bullets:
-                                return
-                            list_items = []
-                            for bullet_nodes in pending_bullets:
-                                list_items.append({
-                                    "type": "list_item",
-                                    "content": [{"type": "paragraph", "content": bullet_nodes}],
-                                })
-                            self.draft_body["content"].append(
-                                {"type": "bullet_list", "content": list_items}
-                            )
-                            pending_bullets.clear()
-
-                        def flush_quotes():
-                            if not pending_quotes:
-                                return
-                            paragraphs: List[Dict] = []
-                            for quote_line in pending_quotes:
-                                tokens = parse_inline(quote_line)
-                                text_nodes = tokens_to_text_nodes(tokens)
-                                if text_nodes:
-                                    paragraphs.append({"type": "paragraph", "content": text_nodes})
-                            node: Dict = {"type": "blockquote"}
-                            if paragraphs:
-                                node["content"] = paragraphs
-                            self.draft_body["content"].append(node)
-                            pending_quotes.clear()
-
-                        def flush_ordered():
-                            if not pending_ordered:
-                                return
-                            list_items = []
-                            for item_nodes in pending_ordered:
-                                list_items.append({
-                                    "type": "list_item",
-                                    "content": [{"type": "paragraph", "content": item_nodes}],
-                                })
-                            self.draft_body["content"].append(
-                                {"type": "ordered_list", "content": list_items}
-                            )
-                            pending_ordered.clear()
-
-                        for line in text_content.split("\n"):
-                            line = line.strip()
-                            if not line:
-                                flush_bullets()
-                                flush_ordered()
-                                flush_quotes()
-                                continue
-
-                            # Check for blockquote marker
-                            if line.startswith("> ") or line == ">":
-                                flush_bullets()
-                                flush_ordered()
-                                quote_text = line[2:] if line.startswith("> ") else ""
-                                pending_quotes.append(quote_text)
-                                continue
-
-                            # Check for ordered list marker
-                            ordered_match = re.match(r'^(\d+)\.\s+(.*)', line)
-                            if ordered_match:
-                                flush_bullets()
-                                flush_quotes()
-                                item_text = ordered_match.group(2).strip()
-                                tokens = parse_inline(item_text)
-                                text_nodes = tokens_to_text_nodes(tokens)
-                                if text_nodes:
-                                    pending_ordered.append(text_nodes)
-                                continue
-
-                            # Check for bullet marker
-                            bullet_text = None
-                            if line.startswith("* "):
-                                bullet_text = line[2:].strip()
-                            elif line.startswith("- "):
-                                bullet_text = line[2:].strip()
-                            elif line.startswith("*") and not line.startswith("**"):
-                                bullet_text = line[1:].strip()
-
-                            if bullet_text is not None:
-                                flush_ordered()
-                                flush_quotes()
-                                tokens = parse_inline(bullet_text)
-                                text_nodes = tokens_to_text_nodes(tokens)
-                                if text_nodes:
-                                    pending_bullets.append(text_nodes)
-                            else:
-                                flush_bullets()
-                                flush_ordered()
-                                flush_quotes()
-                                tokens = parse_inline(line)
-                                self.add({"type": "paragraph", "content": tokens})
-
-                        flush_bullets()
-                        flush_ordered()
-                        flush_quotes()
-                    else:
-                        # Single line — blockquote, ordered list, or paragraph
-                        if text_content.startswith("> ") or text_content == ">":
-                            quote_text = text_content[2:] if text_content.startswith("> ") else ""
-                            tokens = parse_inline(quote_text)
-                            text_nodes = tokens_to_text_nodes(tokens)
-                            para = {"type": "paragraph", "content": text_nodes} if text_nodes else {"type": "paragraph"}
-                            self.draft_body["content"] = self.draft_body.get("content", []) + [
-                                {"type": "blockquote", "content": [para]}
-                            ]
-
-                        elif re.match(r'^(\d+)\.\s+(.*)', text_content):
-                            ordered_match = re.match(r'^(\d+)\.\s+(.*)', text_content)
-                            item_text = ordered_match.group(2).strip()
-                            tokens = parse_inline(item_text)
-                            text_nodes = tokens_to_text_nodes(tokens)
-                            if text_nodes:
-                                list_item = {
-                                    "type": "list_item",
-                                    "content": [{"type": "paragraph", "content": text_nodes}],
-                                }
-                                self.draft_body["content"].append(
-                                    {"type": "ordered_list", "content": [list_item]}
-                                )
-
-                        else:
-                            tokens = parse_inline(text_content)
-                            self.add({"type": "paragraph", "content": tokens})
+        from substack import mdrender
 
+        rendered = mdrender.markdown_to_doc(markdown_content, api=api)
+        self.draft_body["content"] = self.draft_body.get("content", []) + rendered
         return self