chatgpt-md-converter 0.1.0__tar.gz

chatgpt_md_converter-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kostiantyn Kriuchkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chatgpt_md_converter-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: chatgpt_md_converter
+Version: 0.1.0
+Summary: A package for converting markdown to HTML for chat Telegram bots
+Home-page: https://github.com/Latand/formatter-chatgpt-telegram
+Author: Kostiantyn Kriuchkov
+Author-email: latand666@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# ChatGPT Markdown to Telegram HTML Parser
+
+## Overview
+
+This project provides a solution for converting Markdown formatted text into HTML markup supported by the Telegram Bot API, specifically tailored for use in ChatGPT bots developed with the OpenAI API. It includes features for handling various Markdown elements and ensures proper tag closure, making it suitable for streaming mode applications.
+
+## Features
+
+- Converts Markdown syntax to Telegram-compatible HTML.
+- Supports inline code, bold, italic, underline, and strikethrough formatting.
+- Handles nested bold and italic formatting.
+- Converts Markdown links and lists to their HTML equivalents.
+- Processes code blocks with optional language specification, preserving formatting within `<pre><code>` tags.
+- Automatically appends missing closing delimiters for code blocks.
+- Escapes HTML special characters to prevent unwanted HTML rendering outside code blocks.
+
+## Usage
+
+To use the Markdown to Telegram HTML Parser in your ChatGPT bot, integrate the provided Python functions into your bot's processing pipeline. Here is a brief overview of how to incorporate the parser:
+
+1. **Ensure Closing Delimiters**: Automatically appends missing closing delimiters for `` ` `` and ``` ``` ``` to ensure proper parsing.
+
+2. **Extract and Convert Code Blocks**: Extracts Markdown code blocks, converts them to HTML `<pre><code>` format, and replaces them with placeholders to prevent formatting within code blocks.
+
+3. **Markdown to HTML Conversion**: Applies various regex substitutions and custom logic to convert supported Markdown formatting to Telegram-compatible HTML tags.
+
+4. **Reinsert Code Blocks**: Reinserts the previously extracted and converted code blocks back into the main text, replacing placeholders with the appropriate HTML content.
+
+Simply call the `telegram_format(text: str) -> str` function with your Markdown-formatted text as input to receive the converted HTML output ready for use with the Telegram Bot API.
+
+## Example
+
+```python
+formatted_text = telegram_format("Here is some **bold**, __underline__, and `inline code`.\n```python\nprint('Hello, world!')\n```")
+print(formatted_text)
+```
+
+## Requirements
+
+- Python 3.x
+- No external libraries required (uses built-in `re` module for regex operations)
+
+## Contribution
+
+Feel free to contribute to this project by submitting pull requests or opening issues for bugs, feature requests, or improvements.

chatgpt_md_converter-0.1.0/chatgpt_md_converter/converters.py

@@ -0,0 +1,21 @@
+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"{}(.*?){}".format(re.escape(md_tag), re.escape(md_tag)), re.DOTALL
+    )
+    return tag_pattern.sub(r"<{}>\1</{}>".format(html_tag, html_tag), out_text)

chatgpt_md_converter-0.1.0/chatgpt_md_converter/extractors.py

@@ -0,0 +1,55 @@
+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:
+        text += "```"
+    # For single backticks
+    if text.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(1) if match.group(1) else ""
+        code_content = match.group(3)
+        placeholder = f"CODEBLOCKPLACEHOLDER{len(placeholders)}"
+        placeholders.append(placeholder)
+        if not language:
+            html_code_block = f"<pre><code>{code_content}</code></pre>"
+        else:
+            html_code_block = (
+                f'<pre><code class="language-{language}">{code_content}</code></pre>'
+            )
+        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_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-0.1.0/chatgpt_md_converter/formatters.py

@@ -0,0 +1,31 @@
+import re
+
+
+def combine_blockquotes(text: str) -> str:
+    """
+    Combines multiline blockquotes into a single blockquote.
+    """
+    lines = text.split("\n")
+    combined_lines = []
+    blockquote_lines = []
+    in_blockquote = False
+
+    for line in lines:
+        if line.startswith(">"):
+            in_blockquote = True
+            blockquote_lines.append(line[1:].strip())
+        else:
+            if in_blockquote:
+                combined_lines.append(
+                    "<blockquote>" + " ".join(blockquote_lines) + "</blockquote>"
+                )
+                blockquote_lines = []
+                in_blockquote = False
+            combined_lines.append(line)
+
+    if in_blockquote:
+        combined_lines.append(
+            "<blockquote>" + " ".join(blockquote_lines) + "</blockquote>"
+        )
+
+    return "\n".join(combined_lines)

chatgpt_md_converter-0.1.0/chatgpt_md_converter/helpers.py

@@ -0,0 +1,8 @@
+def remove_blockquote_escaping(output: str) -> str:
+    """
+    Removes the escaping from blockquote tags.
+    """
+    output = output.replace("&lt;blockquote&gt;", "<blockquote>").replace(
+        "&lt;/blockquote&gt;", "</blockquote>"
+    )
+    return output

chatgpt_md_converter-0.1.0/chatgpt_md_converter/telegram_formatter.py

@@ -0,0 +1,56 @@
+import re
+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
+
+
+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: Convert HTML reserved symbols
+    text = convert_html_chars(text)
+
+    # Step 2: Extract and convert code blocks first
+    output, code_blocks = extract_and_convert_code_blocks(text)
+
+    # Step 3: Escape HTML special characters in the output text
+    output = output.replace("<", "&lt;").replace(">", "&gt;")
+
+    # Inline code
+    output = re.sub(r"`(.*?)`", r"<code>\1</code>", output)
+
+    # Nested Bold and Italic
+    output = re.sub(r"\*\*\*(.*?)\*\*\*", r"<b><i>\1</i></b>", output)
+
+    # Process markdown formatting tags (bold, underline, italic, strikethrough)
+    # and convert them to their respective HTML tags
+    output = split_by_tag(output, "**", "b")
+    output = split_by_tag(output, "__", "u")
+    output = split_by_tag(output, "_", "i")
+    output = split_by_tag(output, "*", "i")
+    output = split_by_tag(output, "~~", "s")
+
+    # Remove storage links
+    output = re.sub(r"【[^】]+】", "", output)
+
+    # Convert links
+    output = re.sub(r"\[(.*?)\]\((.*?)\)", r'<a href="\2">\1</a>', output)
+
+    # Convert lists
+    output = re.sub(r"^\s*[\-\*] (.+)", r"• \1", output, flags=re.MULTILINE)
+
+    # Convert headings
+    output = re.sub(r"^\s*#+ (.+)", r"<b>\1</b>", output, flags=re.MULTILINE)
+
+    # Step 4: Reinsert the converted HTML code blocks
+    output = reinsert_code_blocks(output, code_blocks)
+
+    # Step 5: Remove blockquote escaping
+    output = remove_blockquote_escaping(output)
+
+    return output

chatgpt_md_converter-0.1.0/chatgpt_md_converter.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: chatgpt_md_converter
+Version: 0.1.0
+Summary: A package for converting markdown to HTML for chat Telegram bots
+Home-page: https://github.com/Latand/formatter-chatgpt-telegram
+Author: Kostiantyn Kriuchkov
+Author-email: latand666@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# ChatGPT Markdown to Telegram HTML Parser
+
+## Overview
+
+This project provides a solution for converting Markdown formatted text into HTML markup supported by the Telegram Bot API, specifically tailored for use in ChatGPT bots developed with the OpenAI API. It includes features for handling various Markdown elements and ensures proper tag closure, making it suitable for streaming mode applications.
+
+## Features
+
+- Converts Markdown syntax to Telegram-compatible HTML.
+- Supports inline code, bold, italic, underline, and strikethrough formatting.
+- Handles nested bold and italic formatting.
+- Converts Markdown links and lists to their HTML equivalents.
+- Processes code blocks with optional language specification, preserving formatting within `<pre><code>` tags.
+- Automatically appends missing closing delimiters for code blocks.
+- Escapes HTML special characters to prevent unwanted HTML rendering outside code blocks.
+
+## Usage
+
+To use the Markdown to Telegram HTML Parser in your ChatGPT bot, integrate the provided Python functions into your bot's processing pipeline. Here is a brief overview of how to incorporate the parser:
+
+1. **Ensure Closing Delimiters**: Automatically appends missing closing delimiters for `` ` `` and ``` ``` ``` to ensure proper parsing.
+
+2. **Extract and Convert Code Blocks**: Extracts Markdown code blocks, converts them to HTML `<pre><code>` format, and replaces them with placeholders to prevent formatting within code blocks.
+
+3. **Markdown to HTML Conversion**: Applies various regex substitutions and custom logic to convert supported Markdown formatting to Telegram-compatible HTML tags.
+
+4. **Reinsert Code Blocks**: Reinserts the previously extracted and converted code blocks back into the main text, replacing placeholders with the appropriate HTML content.
+
+Simply call the `telegram_format(text: str) -> str` function with your Markdown-formatted text as input to receive the converted HTML output ready for use with the Telegram Bot API.
+
+## Example
+
+```python
+formatted_text = telegram_format("Here is some **bold**, __underline__, and `inline code`.\n```python\nprint('Hello, world!')\n```")
+print(formatted_text)
+```
+
+## Requirements
+
+- Python 3.x
+- No external libraries required (uses built-in `re` module for regex operations)
+
+## Contribution
+
+Feel free to contribute to this project by submitting pull requests or opening issues for bugs, feature requests, or improvements.

chatgpt_md_converter-0.1.0/chatgpt_md_converter.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+setup.py
+chatgpt_md_converter/__init__.py
+chatgpt_md_converter/converters.py
+chatgpt_md_converter/extractors.py
+chatgpt_md_converter/formatters.py
+chatgpt_md_converter/helpers.py
+chatgpt_md_converter/telegram_formatter.py
+chatgpt_md_converter.egg-info/PKG-INFO
+chatgpt_md_converter.egg-info/SOURCES.txt
+chatgpt_md_converter.egg-info/dependency_links.txt
+chatgpt_md_converter.egg-info/top_level.txt
+tests/test_parser.py

chatgpt_md_converter-0.1.0/chatgpt_md_converter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chatgpt_md_converter-0.1.0/chatgpt_md_converter.egg-info/top_level.txt

@@ -0,0 +1 @@
+chatgpt_md_converter

chatgpt_md_converter-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chatgpt_md_converter-0.1.0/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup
+
+setup(
+    name="chatgpt_md_converter",
+    version="0.1.0",
+    author="Kostiantyn Kriuchkov",
+    author_email="latand666@gmail.com",
+    description="A package for converting markdown to HTML for chat Telegram bots",
+    long_description=open("README.MD").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Latand/formatter-chatgpt-telegram",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+)

chatgpt_md_converter-0.1.0/tests/test_parser.py

@@ -0,0 +1,256 @@
+from chatgpt_md_converter.telegram_formatter import telegram_format
+
+
+def test_split_by_tag_bold():
+    text = "This is **bold** text"
+    assert telegram_format(text) == "This is <b>bold</b> text"
+
+
+def test_telegram_format_italic():
+    text = "This is _italic_ text"
+    output = telegram_format(text)
+    assert output == "This is <i>italic</i> text"
+
+
+def test_telegram_format_italic_star():
+    text = "This is *italic* text"
+    output = telegram_format(text)
+    assert output == "This is <i>italic</i> text"
+
+
+def test_triple_backticks_with_language():
+    input_text = "```python\nprint('Hello, world!')\n```"
+    expected_output = (
+        "<pre><code class=\"language-python\">print('Hello, world!')\n</code></pre>"
+    )
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed converting triple backticks with language to <pre><code> tags"
+
+
+def test_bold_and_underline_conversion():
+    input_text = "This is **bold** and this is __underline__."
+    expected_output = "This is <b>bold</b> and this is <u>underline</u>."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed converting ** and __ to <b> and <u> tags"
+
+
+def test_escaping_special_characters():
+    input_text = "Avoid using < or > in your HTML."
+    expected_output = "Avoid using &lt; or &gt; in your HTML."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed escaping < and > characters"
+
+
+def test_nested_markdown_syntax():
+    input_text = "This is **bold and _italic_** text."
+    expected_output = "This is <b>bold and <i>italic</i></b> text."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed handling nested markdown syntax"
+
+
+def test_combination_of_markdown_elements():
+    input_text = """
+# Heading
+This is a test of **bold**, __underline__, and `inline code`.
+- Item 1
+* Item 2
+
+```python
+for i in range(3):
+    print(i)
+```
+
+[Link](http://example.com)
+"""
+    expected_output = """<b>Heading</b>\nThis is a test of <b>bold</b>, <u>underline</u>, and <code>inline code</code>.\n• Item 1\n• Item 2\n\n<pre><code class="language-python">for i in range(3):\n    print(i)\n</code></pre>\n\n<a href="http://example.com">Link</a>\n"""
+    output = telegram_format(input_text)
+    assert (
+        output.strip() == expected_output.strip()
+    ), "Failed combining multiple markdown elements into HTML"
+
+
+def test_nested_bold_within_italic():
+    input_text = "This is *__bold within italic__* text."
+    expected_output = "This is <i><u>bold within italic</u></i> text."
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed converting nested bold within italic markdown to HTML"
+
+
+def test_italic_within_bold():
+    input_text = "This is **bold and _italic_ together**."
+    expected_output = "This is <b>bold and <i>italic</i> together</b>."
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed converting italic within bold markdown to HTML"
+
+
+def test_inline_code_within_bold_text():
+    input_text = "This is **bold and `inline code` together**."
+    expected_output = "This is <b>bold and <code>inline code</code> together</b>."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed handling inline code within bold text"
+
+
+def test_mixed_formatting_tags_with_lists_and_links():
+    input_text = """
+- This is a list item with **bold**, __underline__, and [a link](http://example.com)
+- Another item with ***bold and italic*** text
+"""
+    expected_output = """
+• This is a list item with <b>bold</b>, <u>underline</u>, and <a href="http://example.com">a link</a>
+• Another item with <b><i>bold and italic</i></b> text
+"""
+    output = telegram_format(input_text)
+    assert (
+        output.strip() == expected_output.strip()
+    ), "Failed handling mixed formatting tags with lists and links"
+
+
+def test_special_characters_within_code_blocks():
+    input_text = "Here is a code block: ```<script>alert('Hello')</script>```"
+    expected_output = "Here is a code block: <pre><code>&lt;script&gt;alert('Hello')&lt;/script&gt;</code></pre>"
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed escaping special characters within code blocks"
+
+
+def test_code_block_within_bold_text():
+    input_text = "This is **bold with a `code block` inside**."
+    expected_output = "This is <b>bold with a <code>code block</code> inside</b>."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed handling code block within bold text"
+
+
+def test_triple_backticks_with_nested_markdown():
+    input_text = "```python\n**bold text** and __underline__ in code block```"
+    # Expecting the markdown syntax to be ignored within the code block
+    expected_output = '<pre><code class="language-python">**bold text** and __underline__ in code block</code></pre>'
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed handling markdown within triple backtick code blocks"
+
+
+def test_unmatched_code_delimiters():
+    input_text = "This has an `unmatched code delimiter."
+    # Expecting original input as output due to the unmatched delimiter
+    expected_output = "This has an <code>unmatched code delimiter.</code>"
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed handling unmatched code delimiters"
+
+
+def test_preformatted_block_with_unusual_language_specification():
+    input_text = "```weirdLang\nSome weirdLang code\n```"
+    expected_output = (
+        '<pre><code class="language-weirdLang">Some weirdLang code\n</code></pre>'
+    )
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed handling preformatted block with unusual language specification"
+
+
+def test_inline_code_within_lists():
+    input_text = """
+- List item with `code`
+* Another `code` item
+"""
+    expected_output = """
+• List item with <code>code</code>
+• Another <code>code</code> item
+"""
+    output = telegram_format(input_text)
+    assert (
+        output.strip() == expected_output.strip()
+    ), "Failed handling inline code within lists"
+
+
+def test_vector_storage_links_trim():
+    input_text = """
+- List item with `code`
+* Another `code` item【4:0†source】
+"""
+    expected_output = """
+• List item with <code>code</code>
+• Another <code>code</code> item
+"""
+    output = telegram_format(input_text)
+    assert output.strip() == expected_output.strip(), "Failed trim storage links"
+
+
+def test_strikethrough_conversion():
+    input_text = "This is ~~strikethrough~~ text."
+    expected_output = "This is <s>strikethrough</s> text."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed converting ~~ to <s> tags"
+
+
+def test_blockquote_conversion():
+    input_text = "> This is a blockquote."
+    expected_output = "<blockquote>This is a blockquote.</blockquote>"
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed converting > to <blockquote> tags"
+
+
+def test_inline_url_conversion():
+    input_text = "[example](http://example.com)"
+    expected_output = '<a href="http://example.com">example</a>'
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed converting [text](URL) to <a> tags"
+
+
+def test_inline_mention_conversion():
+    input_text = "[User](tg://user?id=123456789)"
+    expected_output = '<a href="tg://user?id=123456789">User</a>'
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed converting [text](tg://user?id=ID) to <a> tags"
+
+
+def test_escaping_ampersand():
+    input_text = "Use & in your HTML."
+    expected_output = "Use &amp; in your HTML."
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed escaping & character"
+
+
+def test_pre_and_code_tags_with_html_entities():
+    input_text = "```html\n<div>Content</div>\n```"
+    expected_output = (
+        '<pre><code class="language-html">&lt;div&gt;Content&lt;/div&gt;\n</code></pre>'
+    )
+    output = telegram_format(input_text)
+    assert (
+        output == expected_output
+    ), "Failed handling pre and code tags with HTML entities"
+
+
+def test_code_with_multiple_lines():
+    input_text = "```\ndef example():\n    return 'example'\n```"
+    expected_output = "<pre><code>def example():\n    return 'example'\n</code></pre>"
+    output = telegram_format(input_text)
+    assert output == expected_output, "Failed handling code with multiple lines"
+
+
+def test_combined_formatting_with_lists():
+    input_text = """
+- **Bold** list item
+- _Italic_ list item
+- `Code` list item
+"""
+    expected_output = """
+• <b>Bold</b> list item
+• <i>Italic</i> list item
+• <code>Code</code> list item
+"""
+    output = telegram_format(input_text)
+    assert (
+        output.strip() == expected_output.strip()
+    ), "Failed handling combined formatting with lists"