python-substack 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

substack/post.py

@@ -11,10 +11,7 @@ from typing import Dict, List
 __all__ = ["Post", "parse_inline", "tokens_to_text_nodes"]
 
 from substack.exceptions import SectionNotExistsException
-
-# Markdown footnotes: ``text.[^label]`` references and ``[^label]: definition`` lines.
-FOOTNOTE_REFERENCE_PATTERN = re.compile(r"\[\^([^\]]+)\]")
-FOOTNOTE_DEFINITION_PATTERN = re.compile(r"^\[\^([^\]]+)\]:\s?(.*)$")
+from substack import nodes
 
 
 def tokens_to_text_nodes(tokens: List[Dict]) -> List[Dict]:
@@ -560,7 +557,7 @@ class Post:
 
         """
         content = self.draft_body["content"][-1].get("content", [])
-        content += [{"type": "footnoteAnchor", "attrs": {"number": number}}]
+        content += [nodes.footnote_anchor(number)]
         self.draft_body["content"][-1]["content"] = content
         return self
 
@@ -586,147 +583,19 @@ class Post:
             for chunk in re.split(r"\n\s*\n", content):
                 chunk = chunk.strip()
                 if chunk:
-                    paragraphs.append(
-                        {"type": "paragraph", "content": tokens_to_text_nodes(parse_inline(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({"type": "paragraph", "content": text_nodes})
-
-        if not paragraphs:
-            paragraphs = [{"type": "paragraph", "content": []}]
+            paragraphs.append(nodes.paragraph(text_nodes))
 
-        node: Dict = {
-            "type": "footnote",
-            "attrs": {"number": number},
-            "content": paragraphs,
-        }
+        node: Dict = nodes.footnote(number, paragraphs)
         self.draft_body["content"] = self.draft_body.get("content", []) + [node]
         return self
 
-    @staticmethod
-    def _extract_footnote_definitions(markdown_content: str):
-        """
-
-        Pull ``[^label]: definition`` lines out of the Markdown.
-
-        Definitions may wrap onto indented continuation lines and may contain
-        multiple paragraphs (blank line followed by an indented block). Returns
-        the body with definitions removed plus a {label: definition_text} mapping,
-        where paragraphs are separated by a blank line.
-
-        """
-        lines = markdown_content.split("\n")
-        body_lines: List[str] = []
-        definitions: Dict[str, str] = {}
-        in_code_fence = False
-        i = 0
-        while i < len(lines):
-            # Track fenced code blocks so footnote-like lines inside them are
-            # left untouched.
-            if lines[i].lstrip().startswith("```"):
-                in_code_fence = not in_code_fence
-                body_lines.append(lines[i])
-                i += 1
-                continue
-            match = None if in_code_fence else FOOTNOTE_DEFINITION_PATTERN.match(lines[i])
-            if match:
-                label, first = match.group(1), match.group(2)
-                paragraphs: List[str] = []
-                current = [first.strip()] if first.strip() else []
-                i += 1
-                while i < len(lines):
-                    line = lines[i]
-                    if line.strip() == "":
-                        # A blank line stays in the footnote only if the next
-                        # non-empty line is indented (a further paragraph).
-                        nxt = i + 1
-                        if (
-                            nxt < len(lines)
-                            and lines[nxt].strip()
-                            and lines[nxt][:1] in (" ", "\t")
-                        ):
-                            if current:
-                                paragraphs.append(" ".join(current))
-                                current = []
-                            i += 1
-                            continue
-                        break
-                    if line[:1] in (" ", "\t"):
-                        current.append(line.strip())
-                        i += 1
-                    else:
-                        break
-                if current:
-                    paragraphs.append(" ".join(current))
-                definitions[label] = "\n\n".join(paragraphs)
-            else:
-                body_lines.append(lines[i])
-                i += 1
-        return "\n".join(body_lines), definitions
-
-    @staticmethod
-    def _number_footnotes(markdown_content: str, definitions: Dict[str, str]):
-        """Number footnotes by order of first inline reference in the body."""
-        order: List[str] = []
-        for match in FOOTNOTE_REFERENCE_PATTERN.finditer(markdown_content):
-            label = match.group(1)
-            if label in definitions and label not in order:
-                order.append(label)
-        # Defined-but-unreferenced footnotes go last, in definition order.
-        for label in definitions:
-            if label not in order:
-                order.append(label)
-        return {label: index + 1 for index, label in enumerate(order)}
-
-    def _inject_footnote_anchors(self, node: Dict, numbers_by_label: Dict[str, int]):
-        """Recursively replace ``[^label]`` in text nodes with footnoteAnchor nodes."""
-        # Never rewrite the contents of a code block.
-        if node.get("type") == "codeBlock":
-            return
-        content = node.get("content")
-        if not isinstance(content, list):
-            return
-        new_content: List[Dict] = []
-        for child in content:
-            text = child.get("text", "")
-            has_code_mark = any(
-                mark.get("type") == "code" for mark in (child.get("marks") or [])
-            )
-            if (
-                child.get("type") == "text"
-                and not has_code_mark
-                and FOOTNOTE_REFERENCE_PATTERN.search(text)
-            ):
-                marks = child.get("marks")
-                last = 0
-                for match in FOOTNOTE_REFERENCE_PATTERN.finditer(text):
-                    label = match.group(1)
-                    if label not in numbers_by_label:
-                        continue  # Unknown label: leave the literal text in place.
-                    if match.start() > last:
-                        segment = {"type": "text", "text": text[last:match.start()]}
-                        if marks:
-                            segment["marks"] = marks
-                        new_content.append(segment)
-                    new_content.append(
-                        {"type": "footnoteAnchor", "attrs": {"number": numbers_by_label[label]}}
-                    )
-                    last = match.end()
-                if last < len(text):
-                    segment = {"type": "text", "text": text[last:]}
-                    if marks:
-                        segment["marks"] = marks
-                    new_content.append(segment)
-            else:
-                self._inject_footnote_anchors(child, numbers_by_label)
-                new_content.append(child)
-        node["content"] = new_content
-
     def from_markdown(self, markdown_content: str, api=None):
         """
         Parse Markdown content and add it to the post.
@@ -760,290 +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).")
         """
-        # Footnotes: extract ``[^label]: ...`` definitions and number them by
-        # order of first reference before parsing the rest of the body.
-        markdown_content, footnote_definitions = self._extract_footnote_definitions(
-            markdown_content
-        )
-        footnote_numbers = self._number_footnotes(markdown_content, footnote_definitions)
-
-        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})
-
-        # Footnotes: turn ``[^label]`` references into inline anchors, then append
-        # the footnote blocks in numbered order.
-        if footnote_numbers:
-            self._inject_footnote_anchors(self.draft_body, footnote_numbers)
-            for label, number in sorted(footnote_numbers.items(), key=lambda item: item[1]):
-                self.footnote(number, footnote_definitions[label])
+        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