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

chatgpt_md_converter/__init__.py

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

chatgpt_md_converter/html_markdown/escaping.py

@@ -0,0 +1,68 @@
+"""Shared escaping utilities for Telegram Markdown conversion."""
+
+from __future__ import annotations
+
+import html
+import re
+
+from .tree import Node
+
+_SIMPLE_STAR_ITALIC = re.compile(
+    r"(?<!\\)(?<!\*)\*(?=[^\s])([^\*\n]+?)(?<!\s)\*(?![A-Za-z0-9\*])",
+)
+
+
+def _canonicalize_star_italics(text: str) -> str:
+    def _replace(match: re.Match[str]) -> str:
+        inner = match.group(1)
+        if "*" in inner or "_" in inner or "`" in inner:
+            return match.group(0)
+        return f"_{inner}_"
+
+    return _SIMPLE_STAR_ITALIC.sub(_replace, text)
+
+
+def normalise_text(text: str) -> str:
+    if not text:
+        return ""
+    unescaped = html.unescape(text)
+    return unescaped.replace("\u00a0", " ")
+
+
+def collect_text(node: Node) -> str:
+    if node.kind == "text":
+        return html.unescape(node.text)
+    parts: list[str] = []
+    for child in node.children:
+        if child.kind == "text":
+            parts.append(html.unescape(child.text))
+        elif child.kind == "element":
+            if child.tag.lower() == "br":
+                parts.append("\n")
+            else:
+                parts.append(collect_text(child))
+    return "".join(parts)
+
+
+def escape_inline_code(text: str) -> str:
+    return text.replace("`", "\\`")
+
+
+def escape_link_label(label: str) -> str:
+    escaped = label
+    for ch in "[]()":
+        escaped = escaped.replace(ch, f"\\{ch}")
+    return escaped
+
+
+def escape_link_url(url: str) -> str:
+    return url.replace("\\", "\\\\").replace(")", "\\)")
+
+
+def post_process(markdown: str) -> str:
+    text = re.sub(r"(^|\n)•\s", r"\1- ", markdown)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    text = text.replace("\r", "")
+    text = "\n".join(line.rstrip() for line in text.split("\n"))
+    text = _canonicalize_star_italics(text)
+    return text.strip()

chatgpt_md_converter/html_markdown/handlers.py

@@ -0,0 +1,155 @@
+"""Tag-specific renderers for Telegram Markdown."""
+
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+from .escaping import (collect_text, escape_inline_code, escape_link_label,
+                       escape_link_url, normalise_text)
+from .state import RenderState
+from .tree import Node
+
+InlineHandler = Callable[[Node, RenderState], str]
+
+
+_INLINE_MARKERS: Dict[str, tuple[str, str]] = {
+    "u": ("__", "__"),
+    "ins": ("__", "__"),
+    "s": ("~~", "~~"),
+    "strike": ("~~", "~~"),
+    "del": ("~~", "~~"),
+}
+
+
+def render_nodes(nodes: list[Node], state: RenderState) -> str:
+    return "".join(render_node(node, state) for node in nodes)
+
+
+def render_node(node: Node, state: RenderState) -> str:
+    if node.kind == "text":
+        return normalise_text(node.text)
+
+    handler = TAG_DISPATCH.get(node.tag.lower())
+    if handler:
+        return handler(node, state)
+    return render_nodes(node.children, state)
+
+
+def _handle_bold(node: Node, state: RenderState) -> str:
+    inner_state = state.child(bold_depth=state.bold_depth + 1)
+    inner = render_nodes(node.children, inner_state)
+    return f"**{inner}**"
+
+
+def _handle_italic(node: Node, state: RenderState) -> str:
+    depth = state.italic_depth
+    in_bold = state.bold_depth > 0 and depth == 0
+    marker = "_" if in_bold else ("*" if depth % 2 == 0 else "_")
+    inner_state = state.child(italic_depth=depth + 1)
+    inner = render_nodes(node.children, inner_state)
+    return f"{marker}{inner}{marker}"
+
+
+def _handle_inline_marker(node: Node, state: RenderState) -> str:
+    marker_open, marker_close = _INLINE_MARKERS[node.tag.lower()]
+    inner = render_nodes(node.children, state)
+    return f"{marker_open}{inner}{marker_close}"
+
+
+def _handle_spoiler(node: Node, state: RenderState) -> str:
+    inner = render_nodes(node.children, state)
+    return f"||{inner}||"
+
+
+def _handle_code(node: Node, state: RenderState) -> str:
+    inner = collect_text(node)
+    return f"`{escape_inline_code(inner)}`"
+
+
+def _handle_pre(node: Node, state: RenderState) -> str:
+    children = node.children
+    language: str | None = None
+    content_node: Node
+
+    if len(children) == 1 and children[0].kind == "element" and children[0].tag.lower() == "code":
+        content_node = children[0]
+        class_attr = content_node.attrs.get("class") or ""
+        for part in class_attr.split():
+            if part.startswith("language-"):
+                language = part.split("-", 1)[1]
+                break
+    else:
+        content_node = Node(kind="element", tag="__virtual__", children=children)
+
+    inner_text = collect_text(content_node)
+    fence = f"```{language}" if language else "```"
+    if language or "\n" in inner_text:
+        return f"{fence}\n{inner_text}```"
+    return f"{fence}{inner_text}```"
+
+
+def _handle_link(node: Node, state: RenderState) -> str:
+    href = node.attrs.get("href", "") or ""
+    label = render_nodes(node.children, state)
+    if not label:
+        label = href
+
+    escaped_label = escape_link_label(label)
+    escaped_url = escape_link_url(href)
+
+    if href.startswith("tg://emoji?"):
+        return f"![{escaped_label}]({escaped_url})"
+    return f"[{escaped_label}]({escaped_url})"
+
+
+def _handle_blockquote(node: Node, state: RenderState) -> str:
+    inner = render_nodes(node.children, state)
+    lines = inner.split("\n")
+    expandable = "expandable" in node.attrs
+    rendered: list[str] = []
+    for index, line in enumerate(lines):
+        prefix = "**>" if expandable and index == 0 else ">"
+        stripped = line.rstrip("\r")
+        if expandable:
+            rendered.append(prefix + stripped)
+        else:
+            rendered.append(f"{prefix} {stripped}" if stripped else prefix)
+    return "\n".join(rendered)
+
+
+def _handle_tg_emoji(node: Node, state: RenderState) -> str:
+    emoji_id = node.attrs.get("emoji-id")
+    label = render_nodes(node.children, state)
+    if emoji_id:
+        href = f"tg://emoji?id={emoji_id}"
+        return f"![{escape_link_label(label)}]({href})"
+    return label
+
+
+def _handle_span(node: Node, state: RenderState) -> str:
+    classes = (node.attrs.get("class") or "").split()
+    if any(cls == "tg-spoiler" for cls in classes):
+        return _handle_spoiler(node, state)
+    if any(cls == "tg-emoji" for cls in classes):
+        return render_nodes(node.children, state)
+    return render_nodes(node.children, state)
+
+
+TAG_DISPATCH: Dict[str, Callable[[Node, RenderState], str]] = {
+    "b": _handle_bold,
+    "strong": _handle_bold,
+    "i": _handle_italic,
+    "em": _handle_italic,
+    "u": _handle_inline_marker,
+    "ins": _handle_inline_marker,
+    "s": _handle_inline_marker,
+    "strike": _handle_inline_marker,
+    "del": _handle_inline_marker,
+    "span": _handle_span,
+    "tg-spoiler": _handle_spoiler,
+    "code": _handle_code,
+    "pre": _handle_pre,
+    "a": _handle_link,
+    "blockquote": _handle_blockquote,
+    "tg-emoji": _handle_tg_emoji,
+}

chatgpt_md_converter/html_markdown/renderer.py

@@ -0,0 +1,16 @@
+"""High-level HTML → Telegram Markdown renderer."""
+
+from __future__ import annotations
+
+from typing import List
+
+from .escaping import post_process
+from .handlers import render_nodes
+from .state import RenderState
+from .tree import Node, build_tree
+
+
+def html_to_telegram_markdown(html_text: str) -> str:
+    nodes: List[Node] = build_tree(html_text)
+    markdown = render_nodes(nodes, RenderState())
+    return post_process(markdown)

chatgpt_md_converter/html_markdown/state.py

@@ -0,0 +1,16 @@
+"""Rendering state for HTML → Telegram Markdown conversion."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RenderState:
+    bold_depth: int = 0
+    italic_depth: int = 0
+
+    def child(self, **updates: int) -> "RenderState":
+        data = {"bold_depth": self.bold_depth, "italic_depth": self.italic_depth}
+        data.update(updates)
+        return RenderState(**data)

chatgpt_md_converter/html_markdown/tree.py

@@ -0,0 +1,65 @@
+"""DOM-like tree construction for Telegram HTML fragments."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from html.parser import HTMLParser
+from typing import Dict, List, Optional
+
+
+@dataclass
+class Node:
+    kind: str  # "text" or "element"
+    text: str = ""
+    tag: str = ""
+    attrs: Dict[str, Optional[str]] = field(default_factory=dict)
+    children: List["Node"] = field(default_factory=list)
+
+
+class _HTMLTreeBuilder(HTMLParser):
+    SELF_CLOSING_TAGS = {"br"}
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=False)
+        self.root = Node(kind="element", tag="__root__")
+        self._stack: List[Node] = [self.root]
+
+    def handle_starttag(self, tag: str, attrs: List[tuple[str, Optional[str]]]) -> None:
+        if tag in self.SELF_CLOSING_TAGS:
+            if tag == "br":
+                self._stack[-1].children.append(Node(kind="text", text="\n"))
+            return
+        node = Node(kind="element", tag=tag, attrs=dict(attrs))
+        self._stack[-1].children.append(node)
+        self._stack.append(node)
+
+    def handle_endtag(self, tag: str) -> None:
+        for index in range(len(self._stack) - 1, 0, -1):
+            if self._stack[index].tag == tag:
+                del self._stack[index:]
+                return
+
+    def handle_startendtag(self, tag: str, attrs: List[tuple[str, Optional[str]]]) -> None:
+        if tag in self.SELF_CLOSING_TAGS:
+            self.handle_starttag(tag, attrs)
+            return
+        node = Node(kind="element", tag=tag, attrs=dict(attrs))
+        self._stack[-1].children.append(node)
+
+    def handle_data(self, data: str) -> None:
+        if data:
+            self._stack[-1].children.append(Node(kind="text", text=data))
+
+    def handle_entityref(self, name: str) -> None:
+        self.handle_data(f"&{name};")
+
+    def handle_charref(self, name: str) -> None:
+        self.handle_data(f"&#{name};")
+
+
+def build_tree(html_text: str) -> List[Node]:
+    """Parse HTML and return the list of top-level nodes."""
+    builder = _HTMLTreeBuilder()
+    builder.feed(html_text)
+    builder.close()
+    return builder.root.children

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/html_to_markdown.py

@@ -0,0 +1,5 @@
+"""Backward-compatible entry point for HTML → Telegram Markdown."""
+
+from .html_markdown.renderer import html_to_telegram_markdown
+
+__all__ = ["html_to_telegram_markdown"]

chatgpt_md_converter/telegram_formatter.py

@@ -1,99 +1,3 @@
-import re
+from .telegram_markdown.renderer import telegram_format
 
-from .converters import convert_html_chars, split_by_tag
-from .extractors import extract_and_convert_code_blocks, reinsert_code_blocks
-from .formatters import combine_blockquotes
-from .helpers import remove_blockquote_escaping, remove_spoiler_escaping
-
-
-def extract_inline_code_snippets(text: str):
-    """
-    Extracts inline code (single-backtick content) from the text,
-    replacing it with placeholders, returning modified text and a dict of placeholders -> code text.
-    This ensures characters like '*' or '_' inside inline code won't be interpreted as Markdown.
-    """
-    placeholders = []
-    code_snippets = {}
-    inline_code_pattern = re.compile(r"`([^`]+)`")
-
-    def replacer(match):
-        snippet = match.group(1)
-        placeholder = f"INLINECODEPLACEHOLDER{len(placeholders)}"
-        placeholders.append(placeholder)
-        code_snippets[placeholder] = snippet
-        return placeholder
-
-    new_text = inline_code_pattern.sub(replacer, text)
-    return new_text, code_snippets
-
-
-def telegram_format(text: str) -> str:
-    """
-    Converts markdown in the provided text to HTML supported by Telegram.
-    """
-
-    # Step 0: Combine blockquotes
-    text = combine_blockquotes(text)
-
-    # Step 1: Extract and convert triple-backtick code blocks first
-    output, triple_code_blocks = extract_and_convert_code_blocks(text)
-
-    # Step 2: Extract inline code snippets
-    output, inline_code_snippets = extract_inline_code_snippets(output)
-
-    # Step 3: Convert HTML reserved symbols in the text (not in code blocks)
-    output = convert_html_chars(output)
-
-    # Convert headings (H1-H6)
-    output = re.sub(r"^(#{1,6})\s+(.+)$", r"<b>\2</b>", output, flags=re.MULTILINE)
-
-    # Convert unordered lists (do this before italic detection so that leading '*' is recognized as bullet)
-    output = re.sub(r"^(\s*)[\-\*]\s+(.+)$", r"\1• \2", output, flags=re.MULTILINE)
-
-    # Nested Bold and Italic
-    output = re.sub(r"\*\*\*(.*?)\*\*\*", r"<b><i>\1</i></b>", output)
-    output = re.sub(r"\_\_\_(.*?)\_\_\_", r"<u><i>\1</i></u>", output)
-
-    # Process markdown for bold (**), underline (__), strikethrough (~~), and spoiler (||)
-    output = split_by_tag(output, "**", "b")
-    output = split_by_tag(output, "__", "u")
-    output = split_by_tag(output, "~~", "s")
-    output = split_by_tag(output, "||", 'span class="tg-spoiler"')
-
-    # Custom approach for single-asterisk italic
-    italic_pattern = re.compile(
-        r"(?<![A-Za-z0-9])\*(?=[^\s])(.*?)(?<!\s)\*(?![A-Za-z0-9])", re.DOTALL
-    )
-    output = italic_pattern.sub(r"<i>\1</i>", output)
-
-    # Process single underscore-based italic
-    output = split_by_tag(output, "_", "i")
-
-    # Remove storage links (Vector storage placeholders like 【4:0†source】)
-    output = re.sub(r"【[^】]+】", "", output)
-
-    # Convert Markdown links/images to <a href="">…</a>
-    link_pattern = r"(?:!?)\[((?:[^\[\]]|\[.*?\])*)\]\(([^)]+)\)"
-    output = re.sub(link_pattern, r'<a href="\2">\1</a>', output)
-
-    # Step 4: Reinsert inline code snippets, applying HTML escaping to the content
-    for placeholder, snippet in inline_code_snippets.items():
-        # Apply HTML escaping to the content of inline code
-        escaped_snippet = (
-            snippet.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-        )
-        output = output.replace(placeholder, f"<code>{escaped_snippet}</code>")
-
-    # Step 5: Reinsert the converted triple-backtick code blocks
-    output = reinsert_code_blocks(output, triple_code_blocks)
-
-    # Step 6: Remove blockquote escaping
-    output = remove_blockquote_escaping(output)
-
-    # Step 7: Remove spoiler tag escaping
-    output = remove_spoiler_escaping(output)
-
-    # Clean up multiple consecutive newlines, but preserve intentional spacing
-    output = re.sub(r"\n{3,}", "\n\n", output)
-
-    return output.strip()
+__all__ = ['telegram_format']

chatgpt_md_converter/telegram_markdown/__init__.py

@@ -0,0 +1,5 @@
+"""Modular Telegram Markdown → HTML conversion helpers."""
+
+from .renderer import telegram_format
+
+__all__ = ["telegram_format"]

chatgpt_md_converter/telegram_markdown/code_blocks.py

@@ -0,0 +1,95 @@
+"""Code block extraction utilities for Telegram Markdown conversion."""
+
+import re
+
+_CODE_BLOCK_RE = re.compile(
+    r"(?P<fence>`{3,})(?P<lang>\w+)?\n?[\s\S]*?(?<=\n)?(?P=fence)",
+    flags=re.DOTALL,
+)
+
+
+
+def _count_unescaped_backticks(text: str) -> int:
+    """Return the number of backticks not escaped by a backslash."""
+    count = 0
+    for index, char in enumerate(text):
+        if char != "`":
+            continue
+        backslashes = 0
+        j = index - 1
+        while j >= 0 and text[j] == '\\':
+            backslashes += 1
+            j -= 1
+        if backslashes % 2 == 0:
+            count += 1
+    return count
+
+def ensure_closing_delimiters(text: str) -> str:
+    """Append any missing closing backtick fences for Markdown code blocks."""
+    open_fence = None
+    for line in text.splitlines():
+        stripped = line.strip()
+        if open_fence is None:
+            match = re.match(r"^(?P<fence>`{3,})(?P<lang>\w+)?$", stripped)
+            if match:
+                open_fence = match.group("fence")
+        else:
+            if stripped.endswith(open_fence):
+                open_fence = None
+
+    if open_fence is not None:
+        if not text.endswith("\n"):
+            text += "\n"
+        text += open_fence
+
+    cleaned_inline = _CODE_BLOCK_RE.sub("", text)
+    if cleaned_inline.count("```") % 2 != 0:
+        text += "```"
+
+    cleaned_inline = _CODE_BLOCK_RE.sub("", text)
+    if _count_unescaped_backticks(cleaned_inline) % 2 != 0:
+        text += "`"
+
+    return text
+
+
+def extract_and_convert_code_blocks(text: str):
+    """Replace fenced code blocks with placeholders and return HTML renderings."""
+    text = ensure_closing_delimiters(text)
+    placeholders: list[str] = []
+    code_blocks: dict[str, str] = {}
+
+    def _replacement(match: re.Match[str]) -> tuple[str, str]:
+        language = match.group("lang") or ""
+        code_content = match.group("code")
+        escaped = (
+            code_content.replace("&", "&amp;")
+            .replace("<", "&lt;")
+            .replace(">", "&gt;")
+        )
+        placeholder = f"CODEBLOCKPLACEHOLDER{len(placeholders)}"
+        placeholders.append(placeholder)
+        if language:
+            html_block = f'<pre><code class="language-{language}">{escaped}</code></pre>'
+        else:
+            html_block = f"<pre><code>{escaped}</code></pre>"
+        return placeholder, html_block
+
+    modified = text
+    pattern = re.compile(
+        r"(?P<fence>`{3,})(?P<lang>\w+)?\n?(?P<code>[\s\S]*?)(?<=\n)?(?P=fence)",
+        flags=re.DOTALL,
+    )
+    for match in pattern.finditer(text):
+        placeholder, html_block = _replacement(match)
+        code_blocks[placeholder] = html_block
+        modified = modified.replace(match.group(0), placeholder, 1)
+
+    return modified, code_blocks
+
+
+def reinsert_code_blocks(text: str, code_blocks: dict[str, str]) -> str:
+    """Insert rendered HTML code blocks back into their placeholders."""
+    for placeholder, html_block in code_blocks.items():
+        text = text.replace(placeholder, html_block, 1)
+    return text

chatgpt_md_converter/telegram_markdown/inline.py

@@ -0,0 +1,73 @@
+"""Inline text helpers for Telegram Markdown conversion."""
+
+import re
+
+_inline_code_pattern = re.compile(r"`([^`]+)`")
+
+_BOLD_PATTERN = re.compile(r"(?<!\\)\*\*(?=\S)(.*?)(?<=\S)\*\*", re.DOTALL)
+_UNDERLINE_PATTERN = re.compile(
+    r"(?<!\\)(?<![A-Za-z0-9_])__(?=\S)(.*?)(?<=\S)__(?![A-Za-z0-9_])",
+    re.DOTALL,
+)
+_ITALIC_UNDERSCORE_PATTERN = re.compile(
+    r"(?<!\\)(?<![A-Za-z0-9_])_(?=\S)(.*?)(?<=\S)_(?![A-Za-z0-9_])",
+    re.DOTALL,
+)
+_STRIKETHROUGH_PATTERN = re.compile(r"(?<!\\)~~(?=\S)(.*?)(?<=\S)~~", re.DOTALL)
+_SPOILER_PATTERN = re.compile(r"(?<!\\)\|\|(?=\S)([^\n]*?)(?<=\S)\|\|")
+_ITALIC_STAR_PATTERN = re.compile(
+    r"(?<![A-Za-z0-9\\])\*(?!\*)(?=[^\s])(.*?)(?<![\s\\])\*(?![A-Za-z0-9\\])",
+    re.DOTALL,
+)
+
+_PATTERN_MAP = {
+    "**": _BOLD_PATTERN,
+    "__": _UNDERLINE_PATTERN,
+    "_": _ITALIC_UNDERSCORE_PATTERN,
+    "~~": _STRIKETHROUGH_PATTERN,
+    "||": _SPOILER_PATTERN,
+}
+
+
+def convert_html_chars(text: str) -> str:
+    text = text.replace("&", "&amp;")
+    text = text.replace("<", "&lt;")
+    text = text.replace(">", "&gt;")
+    return text
+
+
+def split_by_tag(out_text: str, md_tag: str, html_tag: str) -> str:
+    pattern = _PATTERN_MAP.get(md_tag)
+    if pattern is None:
+        escaped = re.escape(md_tag)
+        pattern = re.compile(
+            rf"(?<!\\){escaped}(?=\S)(.*?)(?<=\S){escaped}",
+            re.DOTALL,
+        )
+
+    def _wrap(match: re.Match[str]) -> str:
+        inner = match.group(1)
+        if html_tag == 'span class="tg-spoiler"':
+            return f'<span class="tg-spoiler">{inner}</span>'
+        return f"<{html_tag}>{inner}</{html_tag}>"
+
+    return pattern.sub(_wrap, out_text)
+
+
+def extract_inline_code_snippets(text: str):
+    placeholders: list[str] = []
+    snippets: dict[str, str] = {}
+
+    def replacer(match: re.Match[str]) -> str:
+        snippet = match.group(1)
+        placeholder = f"INLINECODEPLACEHOLDER{len(placeholders)}"
+        placeholders.append(placeholder)
+        snippets[placeholder] = snippet
+        return placeholder
+
+    modified = _inline_code_pattern.sub(replacer, text)
+    return modified, snippets
+
+
+def apply_custom_italic(text: str) -> str:
+    return _ITALIC_STAR_PATTERN.sub(r"<i>\1</i>", text)

chatgpt_md_converter/{helpers.py → telegram_markdown/postprocess.py}

@@ -1,25 +1,19 @@
+"""Post-processing helpers for Telegram Markdown conversion."""
+
+
 def remove_blockquote_escaping(output: str) -> str:
-    """
-    Removes the escaping from blockquote tags, including expandable blockquotes.
-    """
-    # Regular blockquotes
+    """Unescape blockquote tags produced during formatting."""
     output = output.replace("&lt;blockquote&gt;", "<blockquote>").replace(
         "&lt;/blockquote&gt;", "</blockquote>"
     )
-
-    # Expandable blockquotes
     output = output.replace(
         "&lt;blockquote expandable&gt;", "<blockquote expandable>"
     ).replace("&lt;/blockquote&gt;", "</blockquote>")
-
     return output
 
 
 def remove_spoiler_escaping(output: str) -> str:
-    """
-    Ensures spoiler tags are correctly formatted (rather than being escaped).
-    """
-    # Fix any incorrectly escaped spoiler tags
+    """Ensure spoiler spans remain HTML tags, not escaped text."""
     output = output.replace(
         '&lt;span class="tg-spoiler"&gt;', '<span class="tg-spoiler">'
     )

chatgpt_md_converter/telegram_markdown/preprocess.py

@@ -0,0 +1,39 @@
+"""Pre-processing helpers for Telegram Markdown conversion."""
+
+
+def combine_blockquotes(text: str) -> str:
+    """Collapse consecutive Markdown blockquote lines into Telegram HTML blocks."""
+    lines = text.split("\n")
+    combined_lines = []
+    blockquote_lines = []
+    in_blockquote = False
+    is_expandable = False
+
+    for line in lines:
+        if line.startswith("**>"):
+            in_blockquote = True
+            is_expandable = True
+            blockquote_lines.append(line[3:].strip())
+        elif line.startswith(">"):
+            if not in_blockquote:
+                in_blockquote = True
+                is_expandable = False
+            blockquote_lines.append(line[1:].strip())
+        else:
+            if in_blockquote:
+                combined_lines.append(_render_blockquote(blockquote_lines, is_expandable))
+                blockquote_lines = []
+                in_blockquote = False
+                is_expandable = False
+            combined_lines.append(line)
+
+    if in_blockquote:
+        combined_lines.append(_render_blockquote(blockquote_lines, is_expandable))
+
+    return "\n".join(combined_lines)
+
+
+def _render_blockquote(lines: list[str], expandable: bool) -> str:
+    if expandable:
+        return "<blockquote expandable>" + "\n".join(lines) + "</blockquote>"
+    return "<blockquote>" + "\n".join(lines) + "</blockquote>"

chatgpt_md_converter/telegram_markdown/renderer.py

@@ -0,0 +1,55 @@
+"""High-level Telegram Markdown → HTML renderer."""
+
+from __future__ import annotations
+
+import re
+
+from .code_blocks import extract_and_convert_code_blocks, reinsert_code_blocks
+from .inline import (apply_custom_italic, convert_html_chars,
+                     extract_inline_code_snippets, split_by_tag)
+from .postprocess import remove_blockquote_escaping, remove_spoiler_escaping
+from .preprocess import combine_blockquotes
+
+
+def telegram_format(text: str) -> str:
+    text = combine_blockquotes(text)
+
+    output, block_map = extract_and_convert_code_blocks(text)
+    output, inline_snippets = extract_inline_code_snippets(output)
+
+    output = convert_html_chars(output)
+
+    output = re.sub(r"^(#{1,6})\s+(.+)$", r"<b>\2</b>", output, flags=re.MULTILINE)
+    output = re.sub(r"^(\s*)[\-\*]\s+(.+)$", r"\1• \2", output, flags=re.MULTILINE)
+
+    output = re.sub(r"\*\*\*(.*?)\*\*\*", r"<b><i>\1</i></b>", output)
+    output = re.sub(r"\_\_\_(.*?)\_\_\_", r"<u><i>\1</i></u>", output)
+
+    output = split_by_tag(output, "**", "b")
+    output = split_by_tag(output, "__", "u")
+    output = split_by_tag(output, "~~", "s")
+    output = split_by_tag(output, "||", 'span class="tg-spoiler"')
+
+    output = apply_custom_italic(output)
+    output = split_by_tag(output, "_", "i")
+
+    output = re.sub(r"【[^】]+】", "", output)
+
+    link_pattern = r"(?:!?)\[((?:[^\[\]]|\[.*?\])*)\]\(([^)]+)\)"
+    output = re.sub(link_pattern, r'<a href="\2">\1</a>', output)
+
+    for placeholder, snippet in inline_snippets.items():
+        escaped = (
+            snippet.replace("&", "&amp;")
+            .replace("<", "&lt;")
+            .replace(">", "&gt;")
+        )
+        output = output.replace(placeholder, f"<code>{escaped}</code>")
+
+    output = reinsert_code_blocks(output, block_map)
+    output = remove_blockquote_escaping(output)
+    output = remove_spoiler_escaping(output)
+
+    output = re.sub(r"\n{3,}", "\n\n", output)
+
+    return output.strip()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatgpt_md_converter
-Version: 0.3.7
+Version: 0.3.9
 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
@@ -114,6 +114,24 @@ Hidden by default
 Multiple lines</blockquote>
 ```
 
+
+## Performance
+
+Benchmarks were recorded on Linux 6.16.6 (Python 3.11.10) using 1,000 iterations per sample.
+
+| Sample       | Direction     | Avg ms/call | Ops/sec |
+|--------------|---------------|-------------|---------|
+| short_inline | Markdown→HTML | 0.043       | 23,476  |
+| short_inline | HTML→Markdown | 0.078       | 12,824  |
+| medium_block | Markdown→HTML | 0.108       |  9,270  |
+| medium_block | HTML→Markdown | 0.155       |  6,437  |
+| long_mixed   | Markdown→HTML | 0.446       |  2,242  |
+| long_mixed   | HTML→Markdown | 0.730       |  1,370  |
+
+These numbers provide a baseline; real-world throughput depends on text length and interpreter speed.
+
+Reproduce the measurements with `python scripts/benchmark.py --iterations 1000 --json benchmarks.json --summary BENCHMARKS.md`.
+
 ## Requirements
 
 - Python 3.x

chatgpt_md_converter-0.3.9.dist-info/RECORD

@@ -0,0 +1,20 @@
+chatgpt_md_converter/__init__.py,sha256=6ts2hnimdBn_qCA15LKuipUjSU9ZCqRk1GbDPc_JjO4,242
+chatgpt_md_converter/html_splitter.py,sha256=DdjJx0I-A9rZHOxS-0LXsy7YUrgrkrtdeqZtEQ7eooA,7853
+chatgpt_md_converter/html_to_markdown.py,sha256=XlLpQD7W_AooWrvTtvrGVwfPPa80tDKWuT1iT6Vzygw,174
+chatgpt_md_converter/telegram_formatter.py,sha256=w3tjoSdRH_UdoFmGeXe7I47dhDIceXuGOA1oCLMnUmM,87
+chatgpt_md_converter/html_markdown/escaping.py,sha256=wJA4vUJQVcxpkJ4sCIYIWKaqffb_O72R93H81hTgTxA,1808
+chatgpt_md_converter/html_markdown/handlers.py,sha256=dJw-IuvFG7eeTVclx9QOS2NEvqlF2K7i3MJ_llt1YYc,4939
+chatgpt_md_converter/html_markdown/renderer.py,sha256=en-fAr3Bhmm4ZndDaPKV8nLVQ_7HpS_NFBSWcrQporY,438
+chatgpt_md_converter/html_markdown/state.py,sha256=sxbz0ucCakI0KgR86EMZx0nvfU1oiqgVUofujFTeKoo,432
+chatgpt_md_converter/html_markdown/tree.py,sha256=ryohrhO2X5QepZev3087qPoGmMznqHDwH00TNGoW6a4,2154
+chatgpt_md_converter/telegram_markdown/__init__.py,sha256=C0Oexz9brpdE-TqEpiAUV78TsZdSrnnH_5yYpEJ03Us,131
+chatgpt_md_converter/telegram_markdown/code_blocks.py,sha256=gQCGqZTtUusK_I6KOGqMGTd-z3TkUZSo4kMrA5g_l04,3065
+chatgpt_md_converter/telegram_markdown/inline.py,sha256=Phe4T5tu7Y7drH17YW-iOVEqGMRNGe1zVxAbd192HDY,2205
+chatgpt_md_converter/telegram_markdown/postprocess.py,sha256=jUf01tAIqHQ1NxNlVGsvU-Yw8SDOHtMoS7MUzaQLf_8,775
+chatgpt_md_converter/telegram_markdown/preprocess.py,sha256=c9Wzs7DUumXgrgndCeHbCfV1qLzXVJlLHOtXC3Ne2Nk,1362
+chatgpt_md_converter/telegram_markdown/renderer.py,sha256=ZX0reJLVC_2Fvw26dnSSpK_xr_Kpfp9oTyQw57FCqu0,1957
+chatgpt_md_converter-0.3.9.dist-info/licenses/LICENSE,sha256=SDr2jeP-s2g4vf17-jdLXrrqA4_mU7L_RtSJlv4Y2mk,1077
+chatgpt_md_converter-0.3.9.dist-info/METADATA,sha256=P5508ZIm4iTdBtFpA03j5CDy3E7iXEVnx2tkWSZMGbc,6604
+chatgpt_md_converter-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chatgpt_md_converter-0.3.9.dist-info/top_level.txt,sha256=T2o7csVtZgr-Pwm83aSUkZn0humJmDFNqW38tRSsNqw,21
+chatgpt_md_converter-0.3.9.dist-info/RECORD,,

chatgpt_md_converter/converters.py

@@ -1,27 +0,0 @@
-import re
-
-
-def convert_html_chars(text: str) -> str:
-    """
-    Converts HTML reserved symbols to their respective character references.
-    """
-    text = text.replace("&", "&")
-    text = text.replace("<", "&lt;")
-    text = text.replace(">", "&gt;")
-    return text
-
-
-def split_by_tag(out_text: str, md_tag: str, html_tag: str) -> str:
-    """
-    Splits the text by markdown tag and replaces it with the specified HTML tag.
-    """
-    tag_pattern = re.compile(
-        r"(?<!\w){}(.*?){}(?!\w)".format(re.escape(md_tag), re.escape(md_tag)),
-        re.DOTALL,
-    )
-
-    # Special handling for the tg-spoiler tag
-    if html_tag == 'span class="tg-spoiler"':
-        return tag_pattern.sub(r'<span class="tg-spoiler">\1</span>', out_text)
-
-    return tag_pattern.sub(r"<{}>\1</{}>".format(html_tag, html_tag), out_text)

chatgpt_md_converter/extractors.py

@@ -1,94 +0,0 @@
-import re
-
-
-def ensure_closing_delimiters(text: str) -> str:
-    """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()
-        else:
-            stack.append(fence)
-
-    if stack:
-        text += "\n" + stack[-1]
-
-    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 += "```"
-
-    # Balance single backticks outside fenced blocks.
-    cleaned_inline = code_block_re.sub("", text)
-    if cleaned_inline.count("`") % 2 != 0:
-        text += "`"
-
-    return text
-
-
-def extract_and_convert_code_blocks(text: str):
-    """
-    Extracts code blocks from the text, converting them to HTML <pre><code> format,
-    and replaces them with placeholders. Also ensures closing delimiters for unmatched blocks.
-    """
-    text = ensure_closing_delimiters(text)
-    placeholders = []
-    code_blocks = {}
-
-    def replacer(match):
-        language = match.group("lang") if match.group("lang") else ""
-        code_content = match.group("code")
-
-        # Properly escape HTML entities in code content
-        escaped_content = (
-            code_content.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-        )
-
-        placeholder = f"CODEBLOCKPLACEHOLDER{len(placeholders)}"
-        placeholders.append(placeholder)
-        if not language:
-            html_code_block = f"<pre><code>{escaped_content}</code></pre>"
-        else:
-            html_code_block = (
-                f'<pre><code class="language-{language}">{escaped_content}</code></pre>'
-            )
-        return (placeholder, html_code_block)
-
-    modified_text = text
-    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)
-
-    return modified_text, code_blocks
-
-
-def reinsert_code_blocks(text: str, code_blocks: dict) -> str:
-    """
-    Reinserts HTML code blocks into the text, replacing their placeholders.
-    """
-    for placeholder, html_code_block in code_blocks.items():
-        text = text.replace(placeholder, html_code_block, 1)
-    return text

chatgpt_md_converter/formatters.py

@@ -1,68 +0,0 @@
-def combine_blockquotes(text: str) -> str:
-    """
-    Combines multiline blockquotes into a single blockquote while keeping the \n characters.
-    Supports both regular blockquotes (>) and expandable blockquotes (**>).
-    """
-    lines = text.split("\n")
-    combined_lines = []
-    blockquote_lines = []
-    in_blockquote = False
-    is_expandable = False
-
-    for line in lines:
-        if line.startswith("**>"):
-            # Expandable blockquote
-            in_blockquote = True
-            is_expandable = True
-            blockquote_lines.append(line[3:].strip())
-        elif line.startswith(">"):
-            # Regular blockquote
-            if not in_blockquote:
-                # This is a new blockquote
-                in_blockquote = True
-                is_expandable = False
-            blockquote_lines.append(line[1:].strip())
-        else:
-            if in_blockquote:
-                # End of blockquote, combine the lines
-                if is_expandable:
-                    combined_lines.append(
-                        "<blockquote expandable>"
-                        + "\n".join(blockquote_lines)
-                        + "</blockquote>"
-                    )
-                else:
-                    combined_lines.append(
-                        "<blockquote>" + "\n".join(blockquote_lines) + "</blockquote>"
-                    )
-                blockquote_lines = []
-                in_blockquote = False
-                is_expandable = False
-            combined_lines.append(line)
-
-    if in_blockquote:
-        # Handle the case where the file ends with a blockquote
-        if is_expandable:
-            combined_lines.append(
-                "<blockquote expandable>"
-                + "\n".join(blockquote_lines)
-                + "</blockquote>"
-            )
-        else:
-            combined_lines.append(
-                "<blockquote>" + "\n".join(blockquote_lines) + "</blockquote>"
-            )
-
-    return "\n".join(combined_lines)
-
-
-def fix_asterisk_equations(text: str) -> str:
-    """
-    Replaces numeric expressions with '*' in them with '×'
-    to avoid accidental italic formatting.
-    e.g. '6*8' -> '6×8', '6 * 8' -> '6×8'
-    """
-    import re
-
-    eq_pattern = re.compile(r"(\d+)\s*\*\s*(\d+)")
-    return eq_pattern.sub(r"\1×\2", text)

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,,