markdown-flow 0.2.64__tar.gz → 0.2.65__tar.gz

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.64
+Version: 0.2.65
 Summary: An agent library designed to parse and process MarkdownFlow documents
 Project-URL: Homepage, https://github.com/ai-shifu/markdown-flow-agent-py
 Project-URL: Bug Tracker, https://github.com/ai-shifu/markdown-flow-agent-py/issues

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/markdown_flow/__init__.py

@@ -88,5 +88,5 @@ __all__ = [
     "replace_variables_in_text",
 ]
 
-__version__ = "0.2.64"
+__version__ = "0.2.65"
 # __version__ = "0.2.45-alpha-1"

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/markdown_flow/formatter/format.py

@@ -34,14 +34,26 @@ def format_content(content: str) -> list[FormattedElement]:
     if len(lines) > 0 and lines[-1] == "" and content.endswith("\n"):
         lines = lines[:-1]
 
+    pending_newlines = 0
+
     for i, line in enumerate(lines):
         # Non-last lines get \n appended; last line only if original content didn't end with \n
         line_content = line + "\n" if i < len(lines) - 1 else line
 
-        # Empty lines are skipped
+        # Empty lines: buffer the \n instead of discarding
         if line.strip() == "":
+            pending_newlines += 1
             continue
 
+        # Consume pending newlines: append to previous element or prepend to current
+        if pending_newlines > 0:
+            extra = "\n" * pending_newlines
+            if elements:
+                elements[-1].content += extra
+            else:
+                line_content = extra + line_content
+            pending_newlines = 0
+
         cr = c.classify_line(line)
 
         if cr.is_append:
@@ -58,6 +70,10 @@ def format_content(content: str) -> list[FormattedElement]:
         last_type = cr.type
         started = True
 
+    # Trailing empty lines: append to last element
+    if pending_newlines > 0 and elements:
+        elements[-1].content += "\n" * pending_newlines
+
     return elements
 
 

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/markdown_flow/formatter/stream.py

@@ -27,6 +27,7 @@ class StreamFormatter:
         self._last_html_number: int = 0
         self._last_type: str = ""
         self._started: bool = False
+        self._pending_newlines: int = 0
 
     # ------------------------------------------------------------------
     # Public API
@@ -52,10 +53,25 @@ class StreamFormatter:
             line = combined[:nl_idx]
             combined = combined[nl_idx + 1 :]
 
-            # Empty lines are skipped (multi-line block internals handled by classifier's IsContinuation)
+            # Empty lines: buffer the \n instead of discarding
             if line.strip() == "":
+                self._pending_newlines += 1
                 continue
 
+            # Consume pending newlines
+            line_content = line + "\n"
+            if self._pending_newlines > 0:
+                extra = "\n" * self._pending_newlines
+                if elements:
+                    elements[-1].content += extra
+                elif self._started:
+                    # Previous elements already returned; prepend to current line
+                    line_content = extra + line_content
+                else:
+                    # Leading empty lines: prepend to first element
+                    line_content = extra + line_content
+                self._pending_newlines = 0
+
             cr = self._classifier.classify_line(line)
 
             if cr.is_append:
@@ -66,7 +82,7 @@ class StreamFormatter:
             if cr.type == ElementType.HTML and not cr.is_continuation and not cr.is_append:
                 self._last_html_number = self._current_number
 
-            elements.append(FormattedElement(content=line + "\n", type=cr.type, number=self._current_number))
+            elements.append(FormattedElement(content=line_content, type=cr.type, number=self._current_number))
             self._last_type = cr.type
             self._started = True
 
@@ -74,17 +90,22 @@ class StreamFormatter:
 
     def flush(self) -> list[FormattedElement]:
         """Release remaining buffered content at stream end."""
-        if not self._line_buffer:
-            return []
-
         remaining = self._line_buffer
         self._line_buffer = ""
 
-        # Empty line is skipped
-        if remaining.strip() == "":
+        if not remaining or remaining.strip() == "":
+            # No real content to flush; any pending newlines are trailing
+            # They cannot be attached since caller must handle via returned list
+            self._pending_newlines = 0
             return []
 
-        cr = self._classifier.classify_line(remaining)
+        # Consume pending newlines: prepend to remaining content
+        if self._pending_newlines > 0:
+            extra = "\n" * self._pending_newlines
+            remaining = extra + remaining
+            self._pending_newlines = 0
+
+        cr = self._classifier.classify_line(remaining.lstrip("\n"))
 
         if cr.is_append:
             self._current_number = self._last_html_number

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/markdown_flow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.64
+Version: 0.2.65
 Summary: An agent library designed to parse and process MarkdownFlow documents
 Project-URL: Homepage, https://github.com/ai-shifu/markdown-flow-agent-py
 Project-URL: Bug Tracker, https://github.com/ai-shifu/markdown-flow-agent-py/issues

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/tests/test_formatter.py

@@ -330,12 +330,43 @@ class TestFormatContent:
         assert len(result) == 2
         assert result[0].number != result[1].number
 
-    def test_empty_lines_filtered(self):
+    def test_empty_lines_preserved_not_standalone(self):
+        """Empty lines don't generate standalone elements but their \\n is preserved."""
         content = "\ntext line\n\n<div>html</div>\n\nmore text\n"
         result = format_content(content)
 
-        for elem in result:
-            assert elem.content.strip() != "", (
-                f"Empty line should be filtered, got element with content {elem.content!r}"
-            )
+        # Still 3 elements (no standalone empty-line elements)
         assert len(result) == 3  # text, html, text
+
+        # Leading \n is prepended to first element
+        assert result[0].content.startswith("\n")
+        assert "text line" in result[0].content
+
+        # \n between text and html is appended to text element
+        assert result[0].content.endswith("\n\n")
+
+        # \n between html and more text is appended to html element
+        assert result[1].content.endswith("\n\n")
+
+    def test_multiple_consecutive_empty_lines(self):
+        """Multiple consecutive empty lines are all preserved."""
+        content = "first\n\n\nsecond\n"
+        result = format_content(content)
+        assert len(result) == 2
+        # Two empty lines → two extra \n appended to first element
+        assert result[0].content == "first\n\n\n"
+
+    def test_trailing_empty_lines(self):
+        """Trailing empty lines are appended to last element."""
+        content = "hello\n\n\n"
+        result = format_content(content)
+        assert len(result) == 1
+        assert result[0].content == "hello\n\n\n"
+
+    def test_leading_empty_lines_prepend(self):
+        """Leading empty lines are prepended to first element."""
+        content = "\n\nhello\n"
+        result = format_content(content)
+        assert len(result) == 1
+        # "hello" is the last line after trailing \n stripping, so no trailing \n
+        assert result[0].content == "\n\nhello"

{markdown_flow-0.2.64 → markdown_flow-0.2.65}/tests/test_formatter_stream.py

@@ -222,32 +222,56 @@ class TestStreamFormatterRandomChunk:
 
 
 class TestStreamFormatterEmptyLineFiltering:
-    def test_empty_lines_filtered(self):
+    def test_empty_lines_preserved_not_standalone(self):
+        """Empty lines don't generate standalone elements but \\n is preserved."""
         f = StreamFormatter()
         content = "text line\n\n<div>html</div>\n\n"
         all_elements = f.process(content) + f.flush()
 
-        for elem in all_elements:
-            assert elem.content.strip() != "", (
-                f"Empty line should be filtered, got element with content {elem.content!r}"
-            )
-        assert len(all_elements) == 2  # text + html
+        assert len(all_elements) == 2  # text + html, no standalone empty elements
+        # \n between text and html appended to text element
+        assert all_elements[0].content == "text line\n\n"
 
     def test_leading_empty_lines(self):
+        """Leading empty lines are prepended to first element."""
         f = StreamFormatter()
         content = "\n\nHello\n"
         all_elements = f.process(content) + f.flush()
 
         assert len(all_elements) == 1
-        assert all_elements[0].content.strip() == "Hello"
+        assert all_elements[0].content == "\n\nHello\n"
 
     def test_empty_lines_between_html_and_text(self):
+        """Empty lines between elements are preserved on previous element."""
         f = StreamFormatter()
         content = "<div>slide1</div>\n\n\nNarration text\n\n<div>slide2</div>\n"
         all_elements = f.process(content) + f.flush()
 
-        for elem in all_elements:
-            assert elem.content.strip() != "", (
-                f"Empty line should be filtered, got element with content {elem.content!r}"
-            )
         assert len(all_elements) == 3  # html1, text, html2
+        # Two empty lines appended to html1
+        assert all_elements[0].content == "<div>slide1</div>\n\n\n"
+        # One empty line appended to narration text
+        assert all_elements[1].content == "Narration text\n\n"
+
+    def test_cross_chunk_empty_lines(self):
+        """Empty lines spanning chunk boundaries are preserved."""
+        f = StreamFormatter()
+
+        elems1 = f.process("Hello\n")
+        assert len(elems1) == 1
+
+        elems2 = f.process("\n")  # empty line in separate chunk
+        assert len(elems2) == 0  # no standalone element
+
+        elems3 = f.process("World\n")
+        assert len(elems3) == 1
+        # Pending \n prepended to next element (can't modify already-returned element)
+        assert elems3[0].content == "\nWorld\n"
+
+    def test_multiple_consecutive_empty_lines(self):
+        """Multiple consecutive empty lines are all preserved."""
+        f = StreamFormatter()
+        content = "first\n\n\nsecond\n"
+        all_elements = f.process(content) + f.flush()
+        assert len(all_elements) == 2
+        assert all_elements[0].content == "first\n\n\n"