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

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: python-substack
-Version: 0.1.18
+Version: 0.1.19
 Summary: A Python wrapper around the Substack API.
 License: MIT
 License-File: LICENSE
 Keywords: substack
 Author: Paolo Mazza
 Author-email: mazzapaolo2019@gmail.com
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.9
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-substack"
-version = "0.1.18"
+version = "0.1.19"
 description = "A Python wrapper around the Substack API."
 authors = ["Paolo Mazza <mazzapaolo2019@gmail.com>"]
 license = "MIT"
@@ -16,7 +16,7 @@ homepage = "https://github.com/ma2za/python-substack"
 keywords = ["substack"]
 
 [tool.poetry.dependencies]
-python = "^3.9"
+python = ">=3.9"
 
 requests = "^2.31.0"
 python-dotenv = "^0.21.0"

{python_substack-0.1.18 → python_substack-0.1.19}/substack/api.py

@@ -514,6 +514,67 @@ class Api:
             data={"image": image},
         )
         return Api._handle_response(response=response)
+    
+    def add_tags_to_post(self, post_id: int, tag_names: list) -> dict:
+        """
+        Add multiple tags to a post.
+
+        Args:
+            post_id: The ID of the post to tag.
+            tag_names: A list of tag names to add.
+
+        Returns:
+            A dictionary with the results of applying all tags.
+        """
+        results = []
+        for tag_name in tag_names:
+            result = self.add_tag_to_post(post_id, tag_name)
+            results.append(result)
+        return {"tags_added": results}
+
+    def get_publication_post_tags(self) -> list:
+        """
+        Retrieve all post tags for the current publication.
+
+        Returns:
+            List of tag dicts as returned by Substack API.
+        """
+        response = self._session.get(f"{self.publication_url}/publication/post-tag")
+        return Api._handle_response(response=response)
+
+    def add_tag_to_post(self, post_id: int, tag_name: str) -> dict:
+        """
+        Add a tag to a post by first checking published tags and creating only if needed.
+
+        Args:
+            post_id: The ID of the post to tag.
+            tag_name: The name of the tag to add.
+
+        Returns:
+            The response from applying the tag to the post.
+        """
+        # Fetch existing publication tags first (avoid re-creating an already existing tag)
+        existing_tags = self.get_publication_post_tags() or []
+        existing_tag = next(
+            (tag for tag in existing_tags if tag.get("name") == tag_name),
+            None,
+        )
+
+        if existing_tag is not None:
+            tag_id = existing_tag["id"]
+        else:
+            create_tag_response = self._session.post(
+                f"{self.publication_url}/publication/post-tag",
+                json={"name": tag_name},
+            )
+            tag_data = Api._handle_response(create_tag_response)
+            tag_id = tag_data["id"]
+
+        apply_tag_response = self._session.post(
+            f"{self.publication_url}/post/{post_id}/tag/{tag_id}",
+        )
+        return Api._handle_response(apply_tag_response)
+
 
     def get_categories(self):
         """

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

@@ -227,6 +227,42 @@ class Post:
         item["level"] = level
         return self.add(item)
 
+    def blockquote(self, content=None):
+        """
+        Add a blockquote to the post.
+
+        The blockquote wraps one or more paragraph nodes.
+
+        Args:
+            content: Text string or list of inline token dicts.  When a plain
+                string is provided it is wrapped in a single paragraph node.
+
+        Returns:
+            Self for method chaining.
+        """
+        paragraphs: List[Dict] = []
+        if content is not None:
+            if isinstance(content, str):
+                tokens = parse_inline(content)
+                text_nodes = [
+                    {"type": "text", "text": t["content"]} for t in tokens if t
+                ]
+                if text_nodes:
+                    paragraphs.append({"type": "paragraph", "content": text_nodes})
+            elif isinstance(content, list):
+                for item in content:
+                    if isinstance(item, dict) and item.get("type") == "paragraph":
+                        paragraphs.append(item)
+                    elif isinstance(item, dict):
+                        text_nodes = [{"type": "text", "text": item.get("content", "")}]
+                        paragraphs.append({"type": "paragraph", "content": text_nodes})
+
+        node: Dict = {"type": "blockquote"}
+        if paragraphs:
+            node["content"] = paragraphs
+        self.draft_body["content"] = self.draft_body.get("content", []) + [node]
+        return self
+
     def horizontal_rule(self):
         """
 
@@ -464,6 +500,7 @@ class Post:
           - Linked images: [![Alt](image_url)](link_url) - images that are also links
           - Links: [text](url) - inline links in paragraphs
           - Code blocks: Fenced code blocks with ```language or ```
+          - Blockquotes: Lines starting with '>' (consecutive lines grouped)
           - Paragraphs: Regular text blocks
           - Bullet lists: Lines starting with '*' or '-'
           - Inline formatting: **bold** and *italic* within paragraphs
@@ -611,12 +648,14 @@ class Post:
 
                             self.add({"type": "captionedImage", "src": image_url})
 
-                # Process paragraphs or bullet lists
+                # Process paragraphs, bullet lists, or blockquotes
                 else:
                     if "\n" in text_content:
                         # Process each line, grouping consecutive bullets
-                        # into a single bullet_list node
+                        # into a single bullet_list node and consecutive
+                        # blockquote lines into a single blockquote node.
                         pending_bullets: List[List[Dict]] = []
+                        pending_quotes: List[str] = []
 
                         def flush_bullets():
                             if not pending_bullets:
@@ -632,10 +671,36 @@ class Post:
                             )
                             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 = [
+                                    {"type": "text", "text": t["content"]}
+                                    for t in tokens if t
+                                ]
+                                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()
+
                         for line in text_content.split("\n"):
                             line = line.strip()
                             if not line:
                                 flush_bullets()
+                                flush_quotes()
+                                continue
+
+                            # Check for blockquote marker
+                            if line.startswith("> ") or line == ">":
+                                flush_bullets()
+                                quote_text = line[2:] if line.startswith("> ") else ""
+                                pending_quotes.append(quote_text)
                                 continue
 
                             # Check for bullet marker
@@ -648,18 +713,33 @@ class Post:
                                 bullet_text = line[1:].strip()
 
                             if bullet_text is not None:
+                                flush_quotes()
                                 tokens = parse_inline(bullet_text)
                                 if tokens:
                                     pending_bullets.append(tokens)
                             else:
                                 flush_bullets()
+                                flush_quotes()
                                 tokens = parse_inline(line)
                                 self.add({"type": "paragraph", "content": tokens})
 
                         flush_bullets()
+                        flush_quotes()
                     else:
-                        # Single paragraph
-                        tokens = parse_inline(text_content)
-                        self.add({"type": "paragraph", "content": tokens})
+                        # Single line — could be a blockquote 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 = [
+                                {"type": "text", "text": t["content"]}
+                                for t in tokens if t
+                            ]
+                            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]}
+                            ]
+                        else:
+                            tokens = parse_inline(text_content)
+                            self.add({"type": "paragraph", "content": tokens})
 
         return self