move cut text to comment section

Author: patrickZWY

manual_testing/mastodon_manual_test.py

@@ -5,7 +5,7 @@
 from abstractions import AdoptablePet
 from social_posters.mastodon import PosterMastodon
 
-def postExceed500CharsLimitWithAdoptionLink():
+def post_exceed_500_chars_limit_with_adoption_link():
     pet = AdoptablePet("Brian", 
                         "Labrador Retriever", 
                         "White Labrador", 
@@ -20,7 +20,7 @@ def postExceed500CharsLimitWithAdoptionLink():
                     )
     return pet
 
-def postExceed500CharsLimitWithoutAdoptionLink():
+def post_exceed_500_chars_limit_without_adoption_link():
     pet = AdoptablePet("Vinny", 
                         "Unknown", 
                         "Unknown", 
@@ -36,7 +36,7 @@ def postExceed500CharsLimitWithoutAdoptionLink():
     return pet
 
 
-def postWithin500CharsLimitWithAdoptionLink():
+def post_within_500_chars_limit_with_adoption_link():
     pet = AdoptablePet("Ernie", 
                         "Chicken", 
                         "Unknown", 
@@ -51,7 +51,7 @@ def postWithin500CharsLimitWithAdoptionLink():
                     )
     return pet
 
-def postWithin500CharsLimitWithoutAdoptionLink():
+def post_within_500_chars_limit_without_adoption_link():
     pet = AdoptablePet("Pouncy", 
                         "Cat", 
                         "Unknown", 
@@ -66,7 +66,7 @@ def postWithin500CharsLimitWithoutAdoptionLink():
                     )
     return pet
 
-def postUnicode():
+def post_unicode():
     pet = AdoptablePet("Vinny", 
                         "Unknown", 
                         "Unknown", 
@@ -82,11 +82,11 @@ def postUnicode():
     return pet
 
 testingCases = [
-    postExceed500CharsLimitWithAdoptionLink,
-    postExceed500CharsLimitWithoutAdoptionLink,
-    postWithin500CharsLimitWithAdoptionLink,
-    postWithin500CharsLimitWithoutAdoptionLink,
-    postUnicode
+    post_exceed_500_chars_limit_with_adoption_link,
+    post_exceed_500_chars_limit_without_adoption_link,
+    post_within_500_chars_limit_with_adoption_link,
+    post_within_500_chars_limit_without_adoption_link,
+    post_unicode
 ]
 
 def main():

social_posters/mastodon.py

@@ -8,6 +8,7 @@
 from abstractions import Post, PostResult, SocialPoster, AdoptablePet
 from abstractions import CITY_NAME, CITY_STATE
 
+THREAD_SUFFIX = "\n\nMore details below ⬇️"
 MASTODON_CHARACTER_LIMIT = 500
 TRUNCATION_SUFFIX = "..."
 
@@ -69,10 +70,22 @@ def publish(self, post: Post) -> PostResult:
                 image_path,
                 description=post.alt_text or "Photo of an adoptable pet",
             )
+
+            main_caption, replies = self._format_caption_thread(post)
+
             status = self._session.status_post(
-                self._format_caption(post),
+                main_caption,
                 media_ids=[media["id"]],
             )
+
+            root_status_id = status["id"]
+
+            for reply_text in replies:
+                self._session.status_post(
+                    reply_text,
+                    in_reply_to_id=root_status_id
+                )
+
             return PostResult(
                 success=True,
                 post_id=str(status["id"]),
@@ -85,20 +98,42 @@ def publish(self, post: Post) -> PostResult:
             if image_path and os.path.exists(image_path):
                 os.unlink(image_path)
 
-    def _format_caption(self, post: Post) -> str:
+    def _format_caption_thread(self, post: Post) -> tuple[str, list[str]]:
         tags = " ".join(f"#{tag}" for tag in post.tags if tag)
         tag_suffix = f"\n\n{tags}" if tags else ""
-        available_text_length = MASTODON_CHARACTER_LIMIT - len(tag_suffix)
-
-        if available_text_length <= len(TRUNCATION_SUFFIX):
-            return (tag_suffix[-MASTODON_CHARACTER_LIMIT:]).strip()
 
         caption_text = post.text.strip()
-        if len(caption_text) > available_text_length:
-            caption_text = caption_text[: available_text_length - len(TRUNCATION_SUFFIX)].rstrip()
-            caption_text = f"{caption_text}{TRUNCATION_SUFFIX}"
 
-        return f"{caption_text}{tag_suffix}"
+        if len(caption_text) + len(tag_suffix) <= MASTODON_CHARACTER_LIMIT:
+            return f"{caption_text}{tag_suffix}", []
+
+        main_limit = (
+            MASTODON_CHARACTER_LIMIT 
+            - len(tag_suffix) 
+            - len(THREAD_SUFFIX)
+            - len(TRUNCATION_SUFFIX)
+        )
+
+        main_text, overflow = self._safe_truncate(caption_text, main_limit)
+        
+        main_caption = f"{main_text}{TRUNCATION_SUFFIX}{THREAD_SUFFIX}{tag_suffix}"
+        replies = self._split_reply_chunks(overflow)
+
+
+        return main_caption, replies
+    
+    def _split_reply_chunks(self, text: str) -> list[str]:
+        chunks = []
+        remaining = text.strip()
+
+        while remaining:
+            chunk, remaining = self._safe_truncate(
+                remaining,
+                MASTODON_CHARACTER_LIMIT
+            )
+            chunks.append(chunk)
+
+        return chunks
 
     def _download_image(self, image_url: str) -> str:
         parsed_url = urlparse(image_url)
@@ -110,9 +145,18 @@ def _download_image(self, image_url: str) -> str:
                 if chunk:
                     tmp.write(chunk)
             return tmp.name
+        
+    def _safe_truncate(self, text: str, limit: int) -> tuple[str, str]:
+        if len(text) <= limit:
+            return text, ""
+
+        cut = text.rfind(" ", 0, limit)
+
+        if cut == -1:
+            cut = limit
+        
+        return text[:cut].rstrip(), text[cut:].strip()
 
-    # rearrange so that link is at top
-    # need to test
     def format_post(self, pet:AdoptablePet) -> Post:
         """
         Create a Post from an AdoptablePet.

tests/test_mastodon.py

@@ -6,22 +6,136 @@ class TestMastodonCaption:
     def setup_method(self):
         self.poster = PosterMastodon.__new__(PosterMastodon)
 
+    def reconstruct_text(self, main_caption: str, replies: list[str]) -> str:
+        main_without_tags = main_caption.split("\n\n#")[0]
+        main_without_suffix = (
+            main_without_tags
+            .replace("...", "")
+            .replace("\n\nMore details below ⬇️", "")
+            .strip()
+        )
+
+        return " ".join([main_without_suffix] + replies).strip()
+    
+    def test_thread_preserves_original_text_content(self):
+        original_text = " ".join(f"word{i}" for i in range(300))
+        post = Post(text=original_text, tags=["AdoptDontShop", "Boston"])
+
+        main_caption, replies = self.poster._format_caption_thread(post)
+
+        reconstructed = self.reconstruct_text(main_caption, replies)
+
+        assert reconstructed == original_text
+
+    def test_thread_preserves_original_text_without_spaces(self):
+        original_text = "x" * 1000
+        post = Post(text=original_text, tags=["AdoptDontShop", "Boston"])
+
+        main_caption, replies = self.poster._format_caption_thread(post)
+
+        main_without_tags = main_caption.split("\n\n#")[0]
+        main_without_suffix = (
+            main_without_tags
+            .replace("...", "")
+            .replace("\n\nMore details below ⬇️", "")
+            .strip()
+        )
+
+        reconstructed = main_without_suffix + "".join(replies)
+
+        assert reconstructed == original_text
+
     def test_no_tags(self):
         post = Post(text="Hello, world!")
-        assert self.poster._format_caption(post) == "Hello, world!"
+        main_caption, replies = self.poster._format_caption_thread(post) 
+        assert main_caption == "Hello, world!"
+        assert replies == []
 
     def test_with_tags(self):
         post = Post(text="Meet Poppy!", tags=["AdoptDontShop", "Boston"])
-        assert self.poster._format_caption(post) == "Meet Poppy!\n\n#AdoptDontShop #Boston"
+        main_caption, replies = self.poster._format_caption_thread(post)
+
+        assert main_caption == "Meet Poppy!\n\n#AdoptDontShop #Boston"
+        assert replies == []
 
-    def test_caption_stays_under_limit(self):
+    def test_caption_stays_under_limit_and_creates_reply(self):
+        post = Post(text="x " * 1000, tags=["AdoptDontShop", "Boston"])
+        main_caption, replies = self.poster._format_caption_thread(post)
+
+        assert len(main_caption) <= MASTODON_CHARACTER_LIMIT
+        assert main_caption.endswith("\n\n#AdoptDontShop #Boston")
+        assert "..." in main_caption
+        assert "More details below" in main_caption
+        assert replies
+        assert all(len(reply) <= MASTODON_CHARACTER_LIMIT for reply in replies)
+
+    def test_caption_stays_under_limit_creates_reply(self):
         post = Post(text="x" * 1000, tags=["AdoptDontShop", "Boston"])
-        caption = self.poster._format_caption(post)
+        main_caption, replies = self.poster._format_caption_thread(post)
 
-        assert len(caption) <= MASTODON_CHARACTER_LIMIT
-        assert caption.endswith("\n\n#AdoptDontShop #Boston")
-        assert "..." in caption
+        assert len(main_caption) <= MASTODON_CHARACTER_LIMIT
+        assert main_caption.endswith("\n\n#AdoptDontShop #Boston")
+        assert "..." in main_caption
+        assert "More details below" in main_caption
+        assert replies
+        assert all(len(reply) <= MASTODON_CHARACTER_LIMIT for reply in replies)
 
     def test_empty_tags_are_ignored(self):
         post = Post(text="Meet Poppy!", tags=["AdoptDontShop", "", None, "Boston"])
-        assert self.poster._format_caption(post) == "Meet Poppy!\n\n#AdoptDontShop #Boston"
+        main_caption, replies = self.poster._format_caption_thread(post)
+
+        assert main_caption == "Meet Poppy!\n\n#AdoptDontShop #Boston"
+        assert replies == []
+    
+    def test_long_text_without_tags_creates_replies(self):
+        post = Post(text="hello " * 300)
+        main_caption, replies = self.poster._format_caption_thread(post)
+
+        assert len(main_caption) <= MASTODON_CHARACTER_LIMIT
+        assert replies
+        assert all(len(reply) <= MASTODON_CHARACTER_LIMIT for reply in replies)
+    
+    def test_safe_truncate_does_not_split_words_when_possible(self):
+        kept, remaining = self.poster._safe_truncate("hello world again", 12)
+        assert kept == "hello world"
+        assert remaining == "again"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+