python-substack 0.1.17__tar.gz → 0.1.18__tar.gz

{python_substack-0.1.17 → python_substack-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-substack
-Version: 0.1.17
+Version: 0.1.18
 Summary: A Python wrapper around the Substack API.
 License: MIT
 License-File: LICENSE

{python_substack-0.1.17 → python_substack-0.1.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-substack"
-version = "0.1.17"
+version = "0.1.18"
 description = "A Python wrapper around the Substack API."
 authors = ["Paolo Mazza <mazzapaolo2019@gmail.com>"]
 license = "MIT"

{python_substack-0.1.17 → python_substack-0.1.18}/substack/post.py

@@ -39,40 +39,41 @@ def parse_inline(text: str) -> List[Dict]:
     tokens = []
     # Process text character by character to handle nested formatting
     # We'll use regex to find all markdown patterns, then process them in order
-    
+
     # Find all markdown patterns: links, bold, italic
     # Pattern order: links first (to avoid conflicts), then bold, then italic
     link_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
     bold_pattern = r'\*\*([^*]+)\*\*'
     italic_pattern = r'(?<!\*)\*([^*]+)\*(?!\*)'  # Not preceded or followed by *
-    
+
     # Find all matches with their positions
     matches = []
     for match in re.finditer(link_pattern, text):
         # Skip if it's an image link (starts with ![)
-        if match.start() > 0 and text[match.start()-1:match.start()+1] != "![":
+        # But do NOT skip normal links at position 0.
+        if match.start() == 0 or text[match.start()-1:match.start()+1] != "![":
             matches.append((match.start(), match.end(), "link", match.group(1), match.group(2)))
-    
+
     for match in re.finditer(bold_pattern, text):
         # Check if this range is already covered by a link
         if not any(start <= match.start() < end for start, end, _, _, _ in matches):
             matches.append((match.start(), match.end(), "bold", match.group(1), None))
-    
+
     for match in re.finditer(italic_pattern, text):
         # Check if this range is already covered by a link or bold
         if not any(start <= match.start() < end for start, end, _, _, _ in matches):
             matches.append((match.start(), match.end(), "italic", match.group(1), None))
-    
+
     # Sort matches by position
     matches.sort(key=lambda x: x[0])
-    
+
     # Build tokens
     last_pos = 0
     for start, end, match_type, content, url in matches:
         # Add text before this match
         if start > last_pos:
             tokens.append({"content": text[last_pos:start]})
-        
+
         # Add the formatted content
         if match_type == "link":
             tokens.append({
@@ -89,16 +90,16 @@ def parse_inline(text: str) -> List[Dict]:
                 "content": content,
                 "marks": [{"type": "em"}]
             })
-        
+
         last_pos = end
-    
+
     # Add remaining text
     if last_pos < len(text):
         tokens.append({"content": text[last_pos:]})
-    
+
     # Filter out empty tokens
     tokens = [t for t in tokens if t.get("content")]
-    
+
     return tokens
 
 
@@ -351,7 +352,7 @@ class Post:
         for mark in marks:
             new_mark = {"type": mark.get("type")}
             if mark.get("type") == "link":
-                href = mark.get("href")
+                href = mark.get("href") or mark.get("attrs", {}).get("href")
                 new_mark.update({"attrs": {"href": href}})
             content_marks.append(new_mark)
         content["marks"] = content_marks
@@ -572,7 +573,7 @@ class Post:
                         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
 
@@ -613,22 +614,49 @@ class Post:
                 # Process paragraphs or bullet lists
                 else:
                     if "\n" in text_content:
-                        # Process each line separately (for bullet lists)
+                        # Process each line, grouping consecutive bullets
+                        # into a single bullet_list node
+                        pending_bullets: 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()
+
                         for line in text_content.split("\n"):
                             line = line.strip()
                             if not line:
+                                flush_bullets()
                                 continue
-                            # Remove bullet marker if present
+
+                            # Check for bullet marker
+                            bullet_text = None
                             if line.startswith("* "):
-                                line = line[2:].strip()
+                                bullet_text = line[2:].strip()
                             elif line.startswith("- "):
-                                line = line[2:].strip()
+                                bullet_text = line[2:].strip()
                             elif line.startswith("*") and not line.startswith("**"):
-                                line = line[1:].strip()
-
-                            if line:
+                                bullet_text = line[1:].strip()
+
+                            if bullet_text is not None:
+                                tokens = parse_inline(bullet_text)
+                                if tokens:
+                                    pending_bullets.append(tokens)
+                            else:
+                                flush_bullets()
                                 tokens = parse_inline(line)
                                 self.add({"type": "paragraph", "content": tokens})
+
+                        flush_bullets()
                     else:
                         # Single paragraph
                         tokens = parse_inline(text_content)