chatgpt-md-converter 0.3.6__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,16 +2,44 @@ import re
 
 
 def ensure_closing_delimiters(text: str) -> str:
-    """
-    Ensures that if an opening ` or ``` is found without a matching closing delimiter,
-    the missing delimiter is appended to the end of the text.
-    """
-    # For triple backticks
-    if text.count("```") % 2 != 0:
+    # 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,
+    )
+
+    # 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:
+            if stripped.endswith(open_fence):
+                open_fence = None
+
+    # 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)
+
+    # Balance triple backticks that are not part of a complete fence.
+    if cleaned_inline.count("```") % 2 != 0:
         text += "```"
-    # For single backticks
-    if text.count("`") % 2 != 0:
+
+    # Balance single backticks outside fenced blocks.
+    cleaned_inline = code_block_re.sub("", text)
+    if cleaned_inline.count("`") % 2 != 0:
         text += "`"
+
     return text
 
 
@@ -25,8 +53,8 @@ def extract_and_convert_code_blocks(text: str):
     code_blocks = {}
 
     def replacer(match):
-        language = match.group(1) if match.group(1) else ""
-        code_content = match.group(3)
+        language = match.group("lang") if match.group("lang") else ""
+        code_content = match.group("code")
 
         # Properly escape HTML entities in code content
         escaped_content = (
@@ -44,8 +72,14 @@ def extract_and_convert_code_blocks(text: str):
         return (placeholder, html_code_block)
 
     modified_text = text
-    for match in re.finditer(r"```(\w*)?(\n)?(.*?)```", text, flags=re.DOTALL):
-        placeholder, html_code_block = replacer(match)
+    code_block_pattern = re.compile(
+        r"(?P<fence>`{3,})(?P<lang>\w+)?\n?(?P<code>[\s\S]*?)(?<=\n)?(?P=fence)",
+        flags=re.DOTALL,
+    )
+    for match in code_block_pattern.finditer(text):
+        placeholder, html_code_block = replacer(
+            match
+        )
         code_blocks[placeholder] = html_code_block
         modified_text = modified_text.replace(match.group(0), placeholder, 1)
 
@@ -58,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

@@ -0,0 +1,239 @@
+import re
+from html.parser import HTMLParser
+
+MAX_LENGTH = 4096
+MIN_LENGTH = 500
+
+
+class HTMLTagTracker(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.open_tags = []
+
+    def handle_starttag(self, tag, attrs):
+        # saving tags
+        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):
+        for i in range(len(self.open_tags) - 1, -1, -1):
+            if self.open_tags[i][0] == tag:
+                del self.open_tags[i]
+                break
+
+    def get_open_tags_html(self):
+        parts = []
+        for tag, attrs in self.open_tags:
+            attr_str = ""
+            if attrs:
+                attr_str = " " + " ".join(f'{k}="{v}"' for k, v in attrs)
+            parts.append(f"<{tag}{attr_str}>")
+        return "".join(parts)
+
+    def get_closing_tags_html(self):
+        return "".join(f"</{tag}>" for tag, _ in reversed(self.open_tags))
+
+
+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) + overhead > max_length:
+                chunks.append(f"<pre><code{attr}>{buf}</code></pre>")
+                buf = ""
+            buf += line
+        if buf:
+            chunks.append(f"<pre><code{attr}>{buf}</code></pre>")
+        return chunks
+    else:
+        # regular <pre>...</pre>
+        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) + overhead > max_length:
+                chunks.append(f"<pre>{buf}</pre>")
+                buf = ""
+            buf += line
+        if buf:
+            chunks.append(f"<pre>{buf}</pre>")
+        return 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, 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:
+        if len(buf) + len(chunk) <= max_length:
+            buf += chunk
+        else:
+            if buf:
+                merged.append(buf)
+            buf = chunk.lstrip("\n") if trim_empty_leading_lines and merged else chunk
+    if buf:
+        merged.append(buf.lstrip("\n") if trim_empty_leading_lines and merged else buf)
+
+    return merged

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: chatgpt_md_converter
-Version: 0.3.6
+Version: 0.3.8
 Summary: A package for converting markdown to HTML for chat Telegram bots
-Home-page: https://github.com/Latand/formatter-chatgpt-telegram
+Home-page: https://github.com/botfather-dev/formatter-chatgpt-telegram
 Author: Kostiantyn Kriuchkov
 Author-email: latand666@gmail.com
 Classifier: Programming Language :: Python :: 3

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.6.dist-info → chatgpt_md_converter-0.3.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

chatgpt_md_converter-0.3.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-chatgpt_md_converter/__init__.py,sha256=AfkikySkXsJ8HKQcSlU7B1KBHz54QCGJ7MO5Ka9oWRM,79
-chatgpt_md_converter/converters.py,sha256=fgebhbhMcIOqnr0xuV04v81RD91FfaGfA0kO417cDqc,831
-chatgpt_md_converter/extractors.py,sha256=WU38iAG-MANmilqR73gAvxqqXvx4JT8q3xrac_GRXGI,2071
-chatgpt_md_converter/formatters.py,sha256=UbjRG7bLETIGDaFDbFybwW8dKYBMDmgLmIasJiw_j60,2304
-chatgpt_md_converter/helpers.py,sha256=2Nc9_s0HcLq79mBt7Hje19LzbO6z9mUNgayoMyWkIhI,874
-chatgpt_md_converter/telegram_formatter.py,sha256=YlWW8JUlXqP_3chz53_kj15o4d2uW0RlVsuJVcCrzic,3872
-chatgpt_md_converter-0.3.6.dist-info/licenses/LICENSE,sha256=SDr2jeP-s2g4vf17-jdLXrrqA4_mU7L_RtSJlv4Y2mk,1077
-chatgpt_md_converter-0.3.6.dist-info/METADATA,sha256=_cmiJutFIaPt17LD9VOf650BzsPjaBIkD-VUSYpVtJM,5785
-chatgpt_md_converter-0.3.6.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-chatgpt_md_converter-0.3.6.dist-info/top_level.txt,sha256=T2o7csVtZgr-Pwm83aSUkZn0humJmDFNqW38tRSsNqw,21
-chatgpt_md_converter-0.3.6.dist-info/RECORD,,