chatgpt-md-converter 0.3.7__py3-none-any.whl → 0.3.8__py3-none-any.whl

chatgpt_md_converter/__init__.py

@@ -1,3 +1,4 @@
 from .telegram_formatter import telegram_format
+from .html_splitter import split_html_for_telegram
 
-__all__ = ["telegram_format"]
+__all__ = ["telegram_format", "split_html_for_telegram"]

chatgpt_md_converter/extractors.py

@@ -2,31 +2,32 @@ import re
 
 
 def ensure_closing_delimiters(text: str) -> str:
-    """Append missing closing backtick delimiters."""
+    # Append missing closing backtick delimiters.
 
     code_block_re = re.compile(
         r"(?P<fence>`{3,})(?P<lang>\w+)?\n?[\s\S]*?(?<=\n)?(?P=fence)",
         flags=re.DOTALL,
     )
 
-    # Remove complete code blocks from consideration so inner backticks
-    # don't affect delimiter balancing.
-    cleaned = code_block_re.sub("", text)
-
-    # Detect unclosed fences by tracking opening fence lengths.
-    stack = []
-    for line in cleaned.splitlines():
-        m = re.match(r"^(?P<fence>`{3,})(?P<lang>\w+)?$", line.strip())
-        if not m:
-            continue
-        fence = m.group("fence")
-        if stack and fence == stack[-1]:
-            stack.pop()
+    # Track an open fence.  Once a fence is opened, everything until the same
+    # fence is encountered again is treated as plain text.  This mimics how
+    # Markdown handles fences and allows fence-like strings inside code blocks.
+    open_fence = None
+    for line in text.splitlines():
+        stripped = line.strip()
+        if open_fence is None:
+            m = re.match(r"^(?P<fence>`{3,})(?P<lang>\w+)?$", stripped)
+            if m:
+                open_fence = m.group("fence")
         else:
-            stack.append(fence)
+            if stripped.endswith(open_fence):
+                open_fence = None
 
-    if stack:
-        text += "\n" + stack[-1]
+    # If a fence was left open, append a matching closing fence.
+    if open_fence is not None:
+        if not text.endswith("\n"):
+            text += "\n"
+        text += open_fence
 
     cleaned_inline = code_block_re.sub("", text)
 
@@ -91,4 +92,4 @@ def reinsert_code_blocks(text: str, code_blocks: dict) -> str:
     """
     for placeholder, html_code_block in code_blocks.items():
         text = text.replace(placeholder, html_code_block, 1)
-    return text
+    return text

chatgpt_md_converter/html_splitter.py

@@ -2,6 +2,7 @@ import re
 from html.parser import HTMLParser
 
 MAX_LENGTH = 4096
+MIN_LENGTH = 500
 
 
 class HTMLTagTracker(HTMLParser):
@@ -11,7 +12,10 @@ class HTMLTagTracker(HTMLParser):
 
     def handle_starttag(self, tag, attrs):
         # saving tags
-        if tag in ("b", "i", "u", "s", "code", "pre", "a", "span", "blockquote"):
+        if tag in (
+                  "b", "i", "u", "s", "code", "pre", "a", "span", "blockquote",
+                  "strong", "em", "ins", "strike", "del", "tg-spoiler", "tg-emoji"
+                  ):
             self.open_tags.append((tag, attrs))
 
     def handle_endtag(self, tag):
@@ -33,15 +37,30 @@ class HTMLTagTracker(HTMLParser):
         return "".join(f"</{tag}>" for tag, _ in reversed(self.open_tags))
 
 
-def split_pre_block(pre_block: str) -> list[str]:
+def split_pre_block(pre_block: str, max_length) -> list[str]:
+    """
+    Splits long HTML-formatted text into chunks suitable for sending via Telegram,
+    preserving valid HTML tag nesting and handling <pre>/<code> blocks separately.
+
+    Args:
+        text (str): The input HTML-formatted string.
+        trim_leading_newlines (bool): If True, removes leading newline characters (`\\n`)
+            from each resulting chunk before sending. This is useful to avoid
+            unnecessary blank space at the beginning of messages in Telegram.
+
+    Returns:
+        list[str]: A list of HTML-formatted message chunks, each within Telegram's length limit.
+    """
+
     # language-aware: <pre><code class="language-python">...</code></pre>
     match = re.match(r"<pre><code(.*?)>(.*)</code></pre>", pre_block, re.DOTALL)
     if match:
         attr, content = match.groups()
         lines = content.splitlines(keepends=True)
         chunks, buf = [], ""
+        overhead = len(f"<pre><code{attr}></code></pre>")
         for line in lines:
-            if len(buf) + len(line) + len('<pre><code></code></pre>') > MAX_LENGTH:
+            if len(buf) + len(line) + overhead > max_length:
                 chunks.append(f"<pre><code{attr}>{buf}</code></pre>")
                 buf = ""
             buf += line
@@ -53,8 +72,9 @@ def split_pre_block(pre_block: str) -> list[str]:
         inner = pre_block[5:-6]
         lines = inner.splitlines(keepends=True)
         chunks, buf = [], ""
+        overhead = len('<pre></pre>')
         for line in lines:
-            if len(buf) + len(line) + len('<pre></pre>') > MAX_LENGTH:
+            if len(buf) + len(line) + overhead > max_length:
                 chunks.append(f"<pre>{buf}</pre>")
                 buf = ""
             buf += line
@@ -63,52 +83,157 @@ def split_pre_block(pre_block: str) -> list[str]:
         return chunks
 
 
-def split_html_for_telegram(text: str) -> list[str]:
-    chunks = []
+def _is_only_tags(block: str) -> bool:
+    return bool(re.fullmatch(r'(?:\s*<[^>]+>\s*)+', block))
+
+
+def _effective_length(content: str) -> int:
+    tracker = HTMLTagTracker()
+    tracker.feed(content)
+    return len(tracker.get_open_tags_html()) + len(content) + len(tracker.get_closing_tags_html())
+
+
+def split_html_for_telegram(text: str, trim_empty_leading_lines: bool = False, max_length: int = MAX_LENGTH) -> list[str]:
+    """Split long HTML-formatted text into Telegram-compatible chunks.
+
+    Parameters
+    ----------
+    text: str
+        Input HTML text.
+    trim_empty_leading_lines: bool, optional
+        If True, removes `\n` sybmols from start of chunks.
+    max_length: int, optional
+        Maximum allowed length for a single chunk (must be >= ``MIN_LENGTH = 500``).
+        Default = 4096 (symbols)
+
+    Returns
+    -------
+    list[str]
+        List of HTML chunks.
+    """
+
+    if max_length < MIN_LENGTH:
+        raise ValueError("max_length should be at least %d" % MIN_LENGTH)
+
     pattern = re.compile(r"(<pre>.*?</pre>|<pre><code.*?</code></pre>)", re.DOTALL)
     parts = pattern.split(text)
 
+    chunks: list[str] = []
+    prefix = ""
+    current = ""
+    whitespace_re = re.compile(r"(\\s+)")
+    tag_re = re.compile(r"(<[^>]+>)")
+
+    def finalize():
+        nonlocal current, prefix
+        tracker = HTMLTagTracker()
+        tracker.feed(prefix + current)
+        chunk = prefix + current + tracker.get_closing_tags_html()
+        chunks.append(chunk)
+        prefix = tracker.get_open_tags_html()
+        current = ""
+
+    def append_piece(piece: str):
+        nonlocal current, prefix
+
+        def split_on_whitespace(chunk: str) -> list[str] | None:
+            parts = [part for part in whitespace_re.split(chunk) if part]
+            if len(parts) <= 1:
+                return None
+            return parts
+
+        def split_on_tags(chunk: str) -> list[str] | None:
+            parts = [part for part in tag_re.split(chunk) if part]
+            if len(parts) <= 1:
+                return None
+            return parts
+
+        def fittable_prefix_length(chunk: str) -> int:
+            low, high = 1, len(chunk)
+            best = 0
+            while low <= high:
+                mid = (low + high) // 2
+                candidate = chunk[:mid]
+                if _effective_length(prefix + current + candidate) <= max_length:
+                    best = mid
+                    low = mid + 1
+                else:
+                    high = mid - 1
+            return best
+
+        while piece:
+            if _effective_length(prefix + current + piece) <= max_length:
+                current += piece
+                return
+
+            if len(piece) > max_length:
+                if _is_only_tags(piece):
+                    raise ValueError("block contains only html tags")
+                splitted = split_on_whitespace(piece)
+                if splitted:
+                    for part in splitted:
+                        append_piece(part)
+                    return
+                tag_split = split_on_tags(piece)
+                if tag_split:
+                    for part in tag_split:
+                        append_piece(part)
+                    return
+            elif current:
+                finalize()
+                continue
+            else:
+                splitted = split_on_whitespace(piece)
+                if splitted:
+                    for part in splitted:
+                        append_piece(part)
+                    return
+                tag_split = split_on_tags(piece)
+                if tag_split:
+                    for part in tag_split:
+                        append_piece(part)
+                    return
+
+            fitted = fittable_prefix_length(piece)
+            if fitted == 0:
+                if current:
+                    finalize()
+                    continue
+                raise ValueError("unable to split content within max_length")
+
+            current += piece[:fitted]
+            piece = piece[fitted:]
+
+            if piece:
+                finalize()
+
+
     for part in parts:
         if not part:
             continue
         if part.startswith("<pre>") or part.startswith("<pre><code"):
-            pre_chunks = split_pre_block(part)
-            chunks.extend(pre_chunks)
-        else:
-            # breaking down regular HTML
-            tracker = HTMLTagTracker()
-            current = ""
-            blocks = re.split(r"(\n\s*\n|<br\s*/?>|\n)", part)
-            for block in blocks:
-                prospective = current + block
-                if len(prospective) > MAX_LENGTH:
-                    tracker.feed(current)
-                    open_tags = tracker.get_open_tags_html()
-                    close_tags = tracker.get_closing_tags_html()
-                    chunks.append(open_tags + current + close_tags)
-                    current = block
-                    tracker = HTMLTagTracker()
-                else:
-                    current = prospective
-            if current.strip():
-                tracker.feed(current)
-                open_tags = tracker.get_open_tags_html()
-                close_tags = tracker.get_closing_tags_html()
-                chunks.append(open_tags + current + close_tags)
-
-    # post-unification: combine chunks if they don't exceed the limit in total
-    merged_chunks = []
+            pre_chunks = split_pre_block(part, max_length=max_length)
+            for pc in pre_chunks:
+                append_piece(pc)
+            continue
+        blocks = re.split(r"(\n\s*\n|<br\s*/?>|\n)", part)
+        for block in blocks:
+            if block:
+                append_piece(block)
+
+    if current:
+        finalize()
+
+    merged: list[str] = []
     buf = ""
     for chunk in chunks:
-        # chunk = chunk.lstrip("\n")  # removing leading line breaks
-
-        if len(buf) + len(chunk) <= MAX_LENGTH:
+        if len(buf) + len(chunk) <= max_length:
             buf += chunk
         else:
             if buf:
-                merged_chunks.append(buf)
-            buf = chunk
+                merged.append(buf)
+            buf = chunk.lstrip("\n") if trim_empty_leading_lines and merged else chunk
     if buf:
-        merged_chunks.append(buf)
+        merged.append(buf.lstrip("\n") if trim_empty_leading_lines and merged else buf)
 
-    return merged_chunks
+    return merged

{chatgpt_md_converter-0.3.7.dist-info → chatgpt_md_converter-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatgpt_md_converter
-Version: 0.3.7
+Version: 0.3.8
 Summary: A package for converting markdown to HTML for chat Telegram bots
 Home-page: https://github.com/botfather-dev/formatter-chatgpt-telegram
 Author: Kostiantyn Kriuchkov

chatgpt_md_converter-0.3.8.dist-info/RECORD

@@ -0,0 +1,12 @@
+chatgpt_md_converter/__init__.py,sha256=HF8fLq9o1A4HMDjPWCQ43NSby_L29Zgd4S_g3ORyyCA,157
+chatgpt_md_converter/converters.py,sha256=fgebhbhMcIOqnr0xuV04v81RD91FfaGfA0kO417cDqc,831
+chatgpt_md_converter/extractors.py,sha256=k1oRlocn0K4OyU3-k2mrhKanKNdU-664t1CTcf8hYdE,3212
+chatgpt_md_converter/formatters.py,sha256=UbjRG7bLETIGDaFDbFybwW8dKYBMDmgLmIasJiw_j60,2304
+chatgpt_md_converter/helpers.py,sha256=2Nc9_s0HcLq79mBt7Hje19LzbO6z9mUNgayoMyWkIhI,874
+chatgpt_md_converter/html_splitter.py,sha256=DdjJx0I-A9rZHOxS-0LXsy7YUrgrkrtdeqZtEQ7eooA,7853
+chatgpt_md_converter/telegram_formatter.py,sha256=YlWW8JUlXqP_3chz53_kj15o4d2uW0RlVsuJVcCrzic,3872
+chatgpt_md_converter-0.3.8.dist-info/licenses/LICENSE,sha256=SDr2jeP-s2g4vf17-jdLXrrqA4_mU7L_RtSJlv4Y2mk,1077
+chatgpt_md_converter-0.3.8.dist-info/METADATA,sha256=ngfuia4mAfiHBySgX_hKii8ty1O9hOkCotqX9Fzidm4,5792
+chatgpt_md_converter-0.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chatgpt_md_converter-0.3.8.dist-info/top_level.txt,sha256=T2o7csVtZgr-Pwm83aSUkZn0humJmDFNqW38tRSsNqw,21
+chatgpt_md_converter-0.3.8.dist-info/RECORD,,

chatgpt_md_converter-0.3.7.dist-info/RECORD

@@ -1,12 +0,0 @@
-chatgpt_md_converter/__init__.py,sha256=AfkikySkXsJ8HKQcSlU7B1KBHz54QCGJ7MO5Ka9oWRM,79
-chatgpt_md_converter/converters.py,sha256=fgebhbhMcIOqnr0xuV04v81RD91FfaGfA0kO417cDqc,831
-chatgpt_md_converter/extractors.py,sha256=uThH9vnjlEwZowCbxvcZreMZUPqUEiuq0nbWva3K-CE,3023
-chatgpt_md_converter/formatters.py,sha256=UbjRG7bLETIGDaFDbFybwW8dKYBMDmgLmIasJiw_j60,2304
-chatgpt_md_converter/helpers.py,sha256=2Nc9_s0HcLq79mBt7Hje19LzbO6z9mUNgayoMyWkIhI,874
-chatgpt_md_converter/html_splitter.py,sha256=8ao4QU5PFDFCHMg8pj5kBqmxSOUO6RfzqQfk4o1F8ms,3897
-chatgpt_md_converter/telegram_formatter.py,sha256=YlWW8JUlXqP_3chz53_kj15o4d2uW0RlVsuJVcCrzic,3872
-chatgpt_md_converter-0.3.7.dist-info/licenses/LICENSE,sha256=SDr2jeP-s2g4vf17-jdLXrrqA4_mU7L_RtSJlv4Y2mk,1077
-chatgpt_md_converter-0.3.7.dist-info/METADATA,sha256=4gweCWqlv3a6pR6FJbf-ycCEToIjCRf2Ohnk5p81bwQ,5792
-chatgpt_md_converter-0.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chatgpt_md_converter-0.3.7.dist-info/top_level.txt,sha256=T2o7csVtZgr-Pwm83aSUkZn0humJmDFNqW38tRSsNqw,21
-chatgpt_md_converter-0.3.7.dist-info/RECORD,,