Telegramify Markdown

https://github.com/sudoskys/telegramify-markdown
Admin
Telegramify Markdown converts raw Markdown to Telegram plain text with MessageEntity pairs,...
Tokens:20,780
Snippets:135
Trust Score:9.5
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Installation

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Install the library using uv or pip.

```bash
uv add telegramify-markdown  # or: pip install telegramify-markdown
```

--------------------------------

### Install telegramify-markdown

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

Install the package using pip, uv, pdm, or poetry. Include the `mermaid` extra for Mermaid diagram support.

```bash
pip install telegramify-markdown
```

```bash
pip install "telegramify-markdown[mermaid]"
```

```bash
uv add telegramify-markdown
```

```bash
uv add "telegramify-markdown[mermaid]"
```

```bash
pdm add telegramify-markdown
```

```bash
poetry add telegramify-markdown
```

--------------------------------

### Install telegramify-markdown

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Install the library using your preferred package manager. The `[mermaid]` extra is required for Mermaid diagram rendering.

```bash
# uv (recommended)
uv add telegramify-markdown
uv add "telegramify-markdown[mermaid]"

# pip
pip install telegramify-markdown
pip install "telegramify-markdown[mermaid]"

# PDM
pdm add telegramify-markdown
pdm add "telegramify-markdown[mermaid]"

# Poetry
poetry add telegramify-markdown
poetry add "telegramify-markdown[mermaid]"
```

--------------------------------

### Install telegramify-markdown

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/llms-full.txt

Install the library via pip. Include the optional mermaid extra for diagram rendering support.

```bash
pip install telegramify-markdown
pip install telegramify-markdown[mermaid]  # optional: Mermaid diagram rendering
```

--------------------------------

### Inline Code Examples

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/tests/exp1.md

Examples of inline code formatting used throughout the documentation.

```markdown
c!ode
```

```markdown
Inline code
```

```markdown
inline fixed-width code
```

--------------------------------

### Configure runtime settings

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

Get and modify the singleton configuration object to customize rendering behavior globally. This includes heading symbols, link symbols, expandable blockquotes, and Mermaid diagram settings.

```python
from telegramify_markdown import convert, telegramify
from telegramify_markdown.config import get_runtime_config
import asyncio

# Get the singleton config
cfg = get_runtime_config()

# Customize heading symbols (emoji prefixes)
cfg.markdown_symbol.heading_level_1 = "📌"  # Default
cfg.markdown_symbol.heading_level_2 = "✏️"   # Default
cfg.markdown_symbol.heading_level_3 = "📚"  # Default
cfg.markdown_symbol.heading_level_4 = "🔖"  # Default
cfg.markdown_symbol.heading_level_5 = ""    # No prefix
cfg.markdown_symbol.heading_level_6 = ""    # No prefix

# For clean output without emoji heading prefixes:
cfg.markdown_symbol.heading_level_1 = ""
cfg.markdown_symbol.heading_level_2 = ""
cfg.markdown_symbol.heading_level_3 = ""
cfg.markdown_symbol.heading_level_4 = ""

# Customize other symbols
cfg.markdown_symbol.link = "🔗"              # Link prefix
cfg.markdown_symbol.image = "🖼"             # Image prefix
cfg.markdown_symbol.task_completed = "✅"    # Checked task list item
cfg.markdown_symbol.task_uncompleted = "☑️"  # Unchecked task list item

# Expandable blockquote settings
# Long quotes (>200 UTF-16 units) become expandable_blockquote
cfg.cite_expandable = True  # Default: True

# Mermaid diagram rendering settings
cfg.mermaid.theme = "default"    # Options: default, dark, forest, neutral
cfg.mermaid.width = 1280         # Image width in pixels (default: 1000)
cfg.mermaid.scale = 2            # Scale factor for higher resolution
cfg.mermaid.image_type = "webp"  # Output format: webp, png, svg

# Now all conversions use these settings
text, entities = convert("# My Heading\n\nWith a [link](https://example.com)")

async def render_with_config():
    results = await telegramify("""
```mermaid
graph TD
    A-->B
```
""")
    return results

# Settings persist across calls
asyncio.run(render_with_config())
```

--------------------------------

### Convert full Markdown to Telegram format

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

This example demonstrates the conversion of various Markdown features, including headings, text formatting, spoilers, inline code, and code blocks, into a Telegram-compatible format.

```python
from telegramify_markdown import convert
import asyncio
from telegramify_markdown import telegramify

# All supported Markdown features
full_markdown = """
# Heading 1 (bold+underline with 📌)
## Heading 2 (bold+underline with ✏️)
### Heading 3 (bold with 📚)
#### Heading 4 (bold with 🔖)
##### Heading 5 (italic)
###### Heading 6 (italic)

**Bold text** and _italic text_ and ~~strikethrough~~

||Spoiler text hidden until clicked||

`inline code` for short snippets

```python
print("Hello, World!")
```

> Blockquote

* Task 1
* Task 2

1. Ordered list item 1
2. Ordered list item 2

[Link](https://example.com)

![Alt text](https://example.com/image.png)
"""

text, entities = convert(full_markdown)

async def render_full_markdown():
    results = await telegramify(full_markdown)
    return results

asyncio.run(render_full_markdown())
```

--------------------------------

### Code Blocks

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/tests/exp1.md

Various fenced code block examples.

```text
Code block
```

```python
# Code block with specified language
print("Hello, World!")
```

```text
print("Hello, Inline Muti!")
```

```text
pre-formatted fixed-width code block
```

```lua
pre-formatted fixed-width code block written in the Python programming language
```

--------------------------------

### Process and Send Full Reports

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

Demonstrates how to process markdown with features like LaTeX conversion and Mermaid rendering, then send the results as text, photos, or files based on content type.

```python
async def send_full_report():
    # Process markdown with all features enabled
    results = await telegramify(
        markdown,
        max_message_length=4090,  # UTF-16 limit per message
        latex_escape=True,        # Convert LaTeX to Unicode
        render_mermaid=True,      # Render Mermaid as images
        min_file_lines=1,         # Extract code blocks with 1+ lines as files
    )

    for item in results:
        if item.content_type == ContentType.TEXT:
            # Send text message with entities
            bot.send_message(
                chat_id,
                item.text,
                entities=[e.to_dict() for e in item.entities],
            )
        elif item.content_type == ContentType.PHOTO:
            # Send rendered Mermaid diagram as photo
            bot.send_photo(
                chat_id,
                (item.file_name, item.file_data),
                caption=item.caption_text or None,
                caption_entities=[e.to_dict() for e in item.caption_entities] or None,
            )
        elif item.content_type == ContentType.FILE:
            # Send extracted code block as document
            bot.send_document(
                chat_id,
                (item.file_name, item.file_data),
                caption=item.caption_text or None,
                caption_entities=[e.to_dict() for e in item.caption_entities] or None,
            )

asyncio.run(send_full_report())

# To keep code blocks inline instead of extracting as files:
results = await telegramify(markdown, min_file_lines=0)

# To skip Mermaid rendering (keeps as pre block):
results = await telegramify(markdown, render_mermaid=False)
```

--------------------------------

### Runtime Configuration

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Customize library behavior such as heading symbols and Mermaid diagram dimensions.

```python
from telegramify_markdown.config import get_runtime_config
cfg = get_runtime_config()
cfg.markdown_symbol.heading_level_1 = "📌"
cfg.cite_expandable = True
cfg.mermaid.width = 1280
```

--------------------------------

### Calculate UTF-16 string length

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

Use utf16_len() to get the length of a string in UTF-16 code units, which is crucial for correctly calculating Telegram entity offsets and lengths, especially for characters outside the Basic Multilingual Plane.

```python
from telegramify_markdown import utf16_len, convert

# Basic ASCII text - UTF-16 length equals Python length
ascii_text = "Hello, World!"
print(f"Python len: {len(ascii_text)}")       # 13
print(f"UTF-16 len: {utf16_len(ascii_text)}")  # 13

# Text with emojis - emojis often need 2 UTF-16 code units
emoji_text = "Hello 👋 World 🌍!"
print(f"Python len: {len(emoji_text)}")       # 17
print(f"UTF-16 len: {utf16_len(emoji_text)}")  # 19

# Mixed content with various Unicode
mixed = "Привет 你好 مرحبا 🎉"
print(f"Python len: {len(mixed)}")       # 18
print(f"UTF-16 len: {utf16_len(mixed)}")  # 19

# Important for calculating correct offsets
text, entities = convert("**Bold** 🎉")
# Entity for "Bold" should have correct UTF-16 offset
bold_entity = entities[0]
print(f"Bold offset: {bold_entity.offset}, length: {bold_entity.length}")

# When manually creating entities, always use utf16_len
from telegramify_markdown.entity import MessageEntity

custom_text = "Hello 🌍 World"
bold_start = utf16_len("Hello 🌍 ")  # Correct offset accounting for emoji
bold_len = utf16_len("World")
entity = MessageEntity(type="bold", offset=bold_start, length=bold_len)
```

--------------------------------

### Execute 2D Dynamic Programming Knapsack

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

Demonstrates the basic usage of the knapsack dynamic programming function with defined weights, values, and capacity.

```python
weights = [1, 2, 3, 4]
values = [10, 20, 30, 40]
capacity = 5

max_value = knapsack_dp(weights, values, capacity)
print(f"Maximum Value (Dynamic Programming): {max_value}")
```

--------------------------------

### convert()

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Synchronous conversion of Markdown to plain text and MessageEntities.

```APIDOC
## convert(md)

### Description
Converts a Markdown string into plain text and a list of MessageEntities. This is the recommended approach for sending messages with complex formatting without using parse_mode.

### Parameters
- **md** (str) - Required - The Markdown formatted string to convert.

### Response
- **text** (str) - The resulting plain text.
- **entities** (list) - A list of MessageEntity objects.
```

--------------------------------

### Configuration

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/llms-full.txt

Allows customization of rendering symbols and behavior for markdown conversion. This includes changing symbols for headings, links, tasks, and enabling expandable blockquotes.

```APIDOC
## Configuration

### Description
Allows customization of rendering symbols and behavior for markdown conversion.

### Method
Access and modify the global runtime configuration object.

### Parameters
None directly for the configuration object itself, but its attributes can be modified.

### Configuration Attributes
- **markdown_symbol.heading_level_1** (str): Symbol for H1 headings.
- **markdown_symbol.heading_level_2** (str): Symbol for H2 headings.
- **markdown_symbol.heading_level_3** (str): Symbol for H3 headings.
- **markdown_symbol.heading_level_4** (str): Symbol for H4 headings.
- **markdown_symbol.link** (str): Symbol for links.
- **markdown_symbol.image** (str): Symbol for images.
- **markdown_symbol.task_completed** (str): Symbol for completed tasks.
- **markdown_symbol.task_uncompleted** (str): Symbol for uncompleted tasks.
- **cite_expandable** (bool): If True, long quotes become expandable blockquotes.

### Request Example
```python
from telegramify_markdown.config import get_runtime_config

cfg = get_runtime_config()
cfg.markdown_symbol.heading_level_1 = "📌"
cfg.markdown_symbol.link = "🔗"
cfg.cite_expandable = True
```

### Response
#### Success Response (200)
Configuration changes are applied globally.

#### Response Example
No direct response, but subsequent calls to `convert` or `telegramify` will use the updated configuration.
```

--------------------------------

### Implement Space-Efficient Dynamic Programming

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

Provides a memory-optimized version of the knapsack algorithm using a 1D array, followed by a test execution.

```python
def knapsack_dp_optimized(weights, values, capacity):
    """
    Solves the 0-1 knapsack problem using space-efficient dynamic programming.
    :param weights: list, weights of the items.
    :param values: list, values of the items.
    :param capacity: int, maximum capacity of the knapsack.
    :return: int, maximum achievable value.
    """
    n = len(weights)
    dp = [0] * (capacity + 1)

    # Fill the DP array
    for i in range(n):
        for j in range(capacity, weights[i] - 1, -1):  # Iterate backward
            dp[j] = max(dp[j], dp[j - weights[i]] + values[i])

    return dp[capacity]


# Testing the space-efficient method
weights = [1, 2, 3, 4]
values = [10, 20, 30, 40]
capacity = 5

max_value = knapsack_dp_optimized(weights, values, capacity)
print(f"Maximum Value (Optimized Dynamic Programming): {max_value}")
```

--------------------------------

### Recursive Knapsack with Memoization (Python)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

Solves the 0-1 knapsack problem using recursion and memoization. Use when the problem can be broken down into overlapping subproblems and optimal substructure is present. Memoization prevents re-computation of solved subproblems.

```python
def knapsack_recursive_memo(weights, values, capacity, n, memo):
    """
    Solves the 0-1 knapsack problem using recursion with memoization.
    :param weights: list, weights of the items.
    :param values: list, values of the items.
    :param capacity: int, maximum capacity of the knapsack.
    :param n: int, number of items being considered.
    :param memo: dict, memoization of subproblems.
    :return: int, maximum achievable value.
    """
    # Base case: no items or no capacity
    if n == 0 or capacity == 0:
        return 0

    # Return the result if the subproblem is already solved
    if (n, capacity) in memo:
        return memo[(n, capacity)]

    # Weight and value of the current item
    current_weight = weights[n - 1]
    current_value = values[n - 1]

    # If the item is too heavy, exclude it and move to the next
    if current_weight > capacity:
        result = knapsack_recursive_memo(weights, values, capacity, n - 1, memo)
    else:
        # Option 1: Exclude the current item
        without_current = knapsack_recursive_memo(weights, values, capacity, n - 1, memo)
        # Option 2: Include the current item
        with_current = current_value + knapsack_recursive_memo(weights, values, capacity - current_weight, n - 1, memo)
        # Take the maximum of both options
        result = max(without_current, with_current)

    # Store the result in the memo dictionary
    memo[(n, capacity)] = result
    return result


# Testing the recursive + memoization method
weights = [1, 2, 3, 4]  # Item weights
values = [10, 20, 30, 40]  # Item values
capacity = 5  # Knapsack capacity
n = len(weights)
memo = {}  # Memo dictionary

max_value = knapsack_recursive_memo(weights, values, capacity, n, memo)
print(f"Maximum Value (Recursive + Memoization): {max_value}")
```

--------------------------------

### Configure Telegramify Runtime Settings

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Customize symbols for headings and links, control expandable quote behavior, and set Mermaid rendering options using `get_runtime_config()`. These settings affect `telegramify()`'s output. The default Mermaid width is `1000`.

```python
from telegramify_markdown.config import get_runtime_config

cfg = get_runtime_config()
cfg.markdown_symbol.heading_level_1 = "📌"
cfg.markdown_symbol.link = "🔗"
cfg.cite_expandable = True  # Long quotes become expandable_blockquote
cfg.mermaid.width = 1280
cfg.mermaid.scale = 2
cfg.mermaid.theme = "default"
cfg.mermaid.image_type = "webp"

# For clean output without emoji heading prefixes:
# cfg.markdown_symbol.heading_level_1 = ""
# cfg.markdown_symbol.heading_level_2 = ""
# cfg.markdown_symbol.heading_level_3 = ""
# cfg.markdown_symbol.heading_level_4 = ""
```

--------------------------------

### Convert Markdown to MarkdownV2

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Use `markdownify()` for a one-step conversion when your middleware only supports `parse_mode="MarkdownV2"` and cannot pass entities. `standardize()` is an alias for `markdownify()`.

```python
from telegramify_markdown import markdownify

mdv2 = markdownify("**Bold** and `code`")
bot.send_message(chat_id, mdv2, parse_mode="MarkdownV2")
```

--------------------------------

### Python Hello World

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_text.md

A standard Python print statement within a fenced code block.

```python
# Code block with specified language
print("Hello, World!")
```

--------------------------------

### Render Mermaid diagrams

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

Asynchronous rendering of Mermaid diagrams using the telegramify function.

```python
mermaid_md = """
```mermaid
sequenceDiagram
    Alice->>Bob: Hello Bob
    Bob-->>Alice: Hi Alice
```
"""

async def render_mermaid():
    results = await telegramify(mermaid_md)
    for item in results:
        print(f"Type: {item.content_type}")

asyncio.run(render_mermaid())
```

--------------------------------

### entities_to_markdownv2(text, entities=None)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Reverse conversion from plain text and entities to a MarkdownV2 string.

```APIDOC
## entities_to_markdownv2(text, entities=None)

### Description
Takes plain text and entities, returning a MarkdownV2 string with correct escaping.

### Parameters
- **text** (str) - Required - Plain text content
- **entities** (list[MessageEntity] | None) - Optional (Default: None) - Entity list (UTF-16 offsets)

### Response
- **str** - The formatted MarkdownV2 string.
```

--------------------------------

### Manual Entity Splitting

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Manually split text and entities into chunks based on UTF-16 length constraints.

```python
from telegramify_markdown import convert, split_entities
text, entities = convert(long_md)
for chunk_text, chunk_entities in split_entities(text, entities, max_utf16_len=4096):
    bot.send_message(chat_id, chunk_text, entities=[e.to_dict() for e in chunk_entities])
```

--------------------------------

### Knapsack DP (Bottom-Up) in Python

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/tests/exp2.md

Solves the 0-1 knapsack problem using a 2D DP table. Use this for a clear, step-by-step implementation of the dynamic programming approach.

```python
def knapsack_dp(weights, values, capacity):
    """
    Solves the 0-1 knapsack problem using dynamic programming.
    :param weights: list, weights of the items.
    :param values: list, values of the items.
    :param capacity: int, maximum capacity of the knapsack.
    :return: int, maximum achievable value.
    """
    n = len(weights)

    # Create a DP table: dp[i][j] stores the max value achievable with i items and capacity j
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]

    # Fill the DP table
    for i in range(1, n + 1):
        for j in range(1, capacity + 1):
            if weights[i - 1] > j:  # Item is too heavy
                dp[i][j] = dp[i - 1][j]
            else:
                # Choose the better of excluding or including the item
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1])

    return dp[n][capacity]


# Testing the dynamic programming method
weights = [1, 2, 3, 4]
values = [10, 20, 30, 40]
capacity = 5

max_value = knapsack_dp(weights, values, capacity)
print(f"Maximum Value (Dynamic Programming): {max_value}")
```

--------------------------------

### Configure markdown symbols

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/llms-full.txt

Customize the symbols used for headings, links, images, and tasks by modifying the runtime configuration.

```python
from telegramify_markdown.config import get_runtime_config

cfg = get_runtime_config()
cfg.markdown_symbol.heading_level_1 = "📌"
cfg.markdown_symbol.heading_level_2 = "✏️"
cfg.markdown_symbol.heading_level_3 = "📚"
cfg.markdown_symbol.heading_level_4 = "🔖"
cfg.markdown_symbol.link = "🔗"
cfg.markdown_symbol.image = "🖼"
cfg.markdown_symbol.task_completed = "✅"
cfg.markdown_symbol.task_uncompleted = "☑️"
cfg.cite_expandable = True  # long quotes become expandable_blockquote
```

--------------------------------

### telegramify()

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Asynchronous conversion that handles long text splitting and content extraction.

```APIDOC
## telegramify(md, max_message_length)

### Description
Asynchronously converts Markdown to a list of content items, automatically splitting long text and extracting code blocks or diagrams as files or photos.

### Parameters
- **md** (str) - Required - The Markdown string.
- **max_message_length** (int) - Optional - Maximum length for text chunks (default 4090).

### Response
- **results** (list) - A list of content objects (Text, File, or Photo).
```

--------------------------------

### Dynamic Programming Knapsack (Python)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

Solves the 0-1 knapsack problem using a bottom-up dynamic programming approach. This method iteratively builds a table to store solutions to subproblems, ensuring optimal solutions are found efficiently.

```python
def knapsack_dp(weights, values, capacity):
    """
    Solves the 0-1 knapsack problem using dynamic programming.
    :param weights: list, weights of the items.
    :param values: list, values of the items.
    :param capacity: int, maximum capacity of the knapsack.
    :return: int, maximum achievable value.
    """
    n = len(weights)

    # Create a DP table: dp[i][j] stores the max value achievable with i items and capacity j
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]

    # Fill the DP table
    for i in range(1, n + 1):
        for j in range(1, capacity + 1):
            if weights[i - 1] > j:  # Item is too heavy
                dp[i][j] = dp[i - 1][j]
            else:
                # Choose the better of excluding or including the item
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1])

    return dp[n][capacity]
```

--------------------------------

### React 0-1 Knapsack Problem Solver

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

This React component handles user input for weights, values, and capacity, and implements the 0-1 Knapsack dynamic programming solution. Ensure weights and values arrays are of the same length and capacity is a valid number.

```jsx
// KnapsackProblem.js
import React, {useState} from "react";

const KnapsackProblem = () => {
    const [weights, setWeights] = useState("");
    const [values, setValues] = useState("");
    const [capacity, setCapacity] = useState("");
    const [result, setResult] = useState(null);

    const solveKnapsack = (weights, values, capacity) => {
        const n = weights.length;
        const dp = Array.from({length: n + 1}, () =>
            Array(capacity + 1).fill(0)
        );

        for (let i = 1; i <= n; i++) {
            for (let j = 1; j <= capacity; j++) {
                if (weights[i - 1] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(
                        dp[i - 1][j],
                        dp[i - 1][j - weights[i - 1]] + values[i - 1]
                    );
                }
            }
        }

        return dp[n][capacity];
    };

    const handleCalculate = () => {
        const weightArray = weights
            .split(",")
            .map((w) => parseInt(w.trim(), 10));
        const valueArray = values
            .split(",")
            .map((v) => parseInt(v.trim(), 10));
        const maxCapacity = parseInt(capacity, 10);

        if (weightArray.length !== valueArray.length || isNaN(maxCapacity)) {
            alert("Invalid inputs!");
            return;
        }

        const maxValue = solveKnapsack(weightArray, valueArray, maxCapacity);
        setResult(maxValue);
    };

    return (
        <div>
            <h1>0-1 Knapsack Problem</h1>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <div> UUID: 0-1-knapsack-problem-1 00000000000000000000000000000000000000000000000000000000</div>
            <p>Enter weights, values, and capacity to calculate the maximum value:</p>
            <div>
                <label>
                    Capacity:
                    <input
                        type="number"
                        value={capacity}
                        onChange={(e) => setCapacity(e.target.value)}
                    />
                </label>
            </div>
            <div>
                <label>
                    Weights (comma-separated):
                    <input
                        type="text"
                        value={weights}
                        onChange={(e) => setWeights(e.target.value)}
                    />
                </label>
            </div>
            <div>
                <label>
                    Values (comma-separated):
                    <input
                        type="text"
                        value={values}
                        onChange={(e) => setValues(e.target.value)}
                    />
                </label>
            </div>
        </div>
    );
};

```

--------------------------------

### Reverse Entity Conversion

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Convert existing text and entities back into a MarkdownV2 string.

```python
from telegramify_markdown import convert, entities_to_markdownv2
text, entities = convert("**Bold** and `code`")
mdv2 = entities_to_markdownv2(text, entities)
bot.send_message(chat_id, mdv2, parse_mode="MarkdownV2")
```

--------------------------------

### Asynchronous Full Pipeline Conversion

Source: https://context7.com/sudoskys/telegramify-markdown/llms.txt

The `telegramify` async function processes Markdown through a full pipeline, including automatic message splitting, code block extraction as files, and Mermaid diagram rendering. It returns a list of content objects ready for the Telegram Bot API.

```python
import asyncio
from telebot import TeleBot
from telegramify_markdown import telegramify
from telegramify_markdown.content import ContentType

bot = TeleBot("YOUR_TOKEN")
chat_id = 123456789

markdown = """
# Analysis Report

Here's some analysis with **bold** formatting and _emphasis_.

## Code Example

```python
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Generate first 10 Fibonacci numbers
for i in range(10):
    print(f"F({i}) = {fibonacci(i)}")
```

## System Architecture

```mermaid
graph TD
    A[User Request] --> B{Load Balancer}
    B --> C[Server 1]
    B --> D[Server 2]
    C --> E[(Database)]
    D --> E
```


```

--------------------------------

### markdownify()

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Direct conversion from Markdown to Telegram MarkdownV2 format.

```APIDOC
## markdownify(md)

### Description
Converts Markdown directly into a MarkdownV2 formatted string, suitable for use with the parse_mode parameter in Telegram bots.

### Parameters
- **md** (str) - Required - The Markdown string.

### Response
- **mdv2** (str) - The formatted MarkdownV2 string.
```

--------------------------------

### telegramify() - Long Messages, Code Files, Diagrams (Async)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/llms-full.txt

An asynchronous function that handles the full pipeline: converts Markdown, splits long messages, extracts code blocks as File objects, and renders Mermaid diagrams as Photo objects. Suitable for complex messages and automated sending.

```APIDOC
## telegramify() - Long Messages, Code Files, Diagrams (Async)

### Description
Async. Full pipeline: converts Markdown, splits long messages, extracts code blocks as File objects, renders Mermaid diagrams as Photo objects.

### Method
`telegramify(content, *, max_message_length=4096, latex_escape=True)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **content** (str) - Required - Raw Markdown text.
- **max_message_length** (int, default 4096) - Optional - Maximum UTF-16 code units per text message.
- **latex_escape** (bool, default True) - Optional - Convert LaTeX to Unicode.

### Request Example
```python
import asyncio
from telegramify_markdown import telegramify
from telegramify_markdown.content import ContentType

async def send_long_message(bot, chat_id, markdown_text):
    results = await telegramify(markdown_text, max_message_length=4090)
    for item in results:
        if item.content_type == ContentType.TEXT:
            bot.send_message(chat_id, item.text, entities=[e.to_dict() for e in item.entities])
        elif item.content_type == ContentType.PHOTO:
            bot.send_photo(chat_id, (item.file_name, item.file_data),
                caption=item.caption_text or None,
                caption_entities=[e.to_dict() for e in item.caption_entities] or None)
        elif item.content_type == ContentType.FILE:
            bot.send_document(chat_id, (item.file_name, item.file_data),
                caption=item.caption_text or None,
                caption_entities=[e.to_dict() for e in item.caption_entities] or None)

# Example usage within an async function:
# asyncio.run(send_long_message(bot, chat_id, "Your very long markdown content..."))
```

### Response
#### Success Response (200)
- Returns an ordered list of Text, File, or Photo objects preserving the original document order.

#### Response Example
```json
[
  {
    "content_type": "TEXT",
    "text": "First part of the message...",
    "entities": [...] 
  },
  {
    "content_type": "PHOTO",
    "file_name": "diagram.png",
    "file_data": "base64_encoded_image_data",
    "caption_text": "Diagram caption",
    "caption_entities": [...] 
  },
  {
    "content_type": "FILE",
    "file_name": "code.py",
    "file_data": "base64_encoded_file_data",
    "caption_text": "Code snippet",
    "caption_entities": [...] 
  }
]
```
```

--------------------------------

### Lua Pre-formatted Code Block

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_text.md

A pre-formatted code block labeled as Lua.

```lua
pre-formatted fixed-width code block written in the Python programming language
```

--------------------------------

### Architecture Flow

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/llms-full.txt

Visual representation of the processing pipeline from Markdown input to Telegram-ready output.

```text
Input Markdown
    │
    ├─ Preprocessing: ||spoiler|| → <tg-spoiler>
    ├─ Preprocessing: LaTeX → Unicode (latex_escape/)
    │
    ▼
pyromark.events(text, options)  → event stream
    │
    ▼
EventWalker state machine (converter.py)
    ├─ Maintains text_buffer + utf16_offset
    ├─ entity_stack: Start → push, End → pop and emit MessageEntity
    ├─ Identifies segments: text / code_block / mermaid
    │
    ▼
convert() → (str, list[MessageEntity])         # sync API
telegramify() → list[Text | File | Photo]      # async pipeline
```

--------------------------------

### telegramify(content, *, max_message_length=4096, latex_escape=True)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Full pipeline for processing Markdown, including splitting long messages and rendering diagrams.

```APIDOC
## telegramify(content, *, max_message_length=4096, latex_escape=True)

### Description
Async function that performs the full pipeline: converts Markdown, splits long messages, extracts code blocks as files, and renders Mermaid diagrams as images.

### Parameters
- **content** (str) - Required - Raw Markdown text
- **max_message_length** (int) - Optional (Default: 4096) - Max UTF-16 code units per text message
- **latex_escape** (bool) - Optional (Default: True) - Convert LaTeX to Unicode

### Response
- **list[Text | File | Photo]** - Returns an ordered list of Text, File, or Photo objects.
```

--------------------------------

### convert(markdown, *, latex_escape=True)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Converts a Markdown string to plain text and a list of MessageEntity objects.

```APIDOC
## convert(markdown, *, latex_escape=True)

### Description
Synchronous function that converts a Markdown string to plain text and a list of MessageEntity objects.

### Parameters
- **markdown** (str) - Required - Raw Markdown text
- **latex_escape** (bool) - Optional (Default: True) - Convert LaTeX \(...\) and \[...\] to Unicode symbols

### Response
- **tuple[str, list[MessageEntity]]** - Returns a tuple containing the plain text and a list of MessageEntity objects.
```

--------------------------------

### Mermaid Diagram

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

A basic flowchart illustrating a process with conditional branching.

```mermaid
graph TD
A[Start] --> B{Condition}
B -->|是的| C[Process 1]
C --> D[Process 2]
D --> E[End]
B -->|No| F[Process 3]
F --> E
```

--------------------------------

### React Knapsack Problem Component

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/tests/exp2.md

This React component provides a user interface for the Knapsack problem. It takes weights, values, and capacity as input, calculates the maximum value using a dynamic programming function, and displays the result.

```javascript
import React, { useState } from 'react';

const KnapsackProblem = () => {
    const [weights, setWeights] = useState('');
    const [values, setValues] = useState('');
    const [capacity, setCapacity] = useState('');
    const [result, setResult] = useState(null);

    const solveKnapsack = (w, v, C) => {
        const n = w.length;
        const dp = Array(n + 1).fill(0).map(() => Array(C + 1).fill(0));

        for (let i = 1; i <= n; i++) {
            for (let j = 1; j <= C; j++) {
                if (w[i - 1] <= j) {
                    dp[i][j] = Math.max(dp[i - 1][j], v[i - 1] + dp[i - 1][j - w[i - 1]]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[n][C];
    };

    const handleCalculate = () => {
        try {
            const parsedWeights = weights.split(',').map(Number);
            const parsedValues = values.split(',').map(Number);
            const parsedCapacity = Number(capacity);

            if (parsedWeights.length !== parsedValues.length) {
                alert('Weights and values arrays must have the same length.');
                return;
            }
            if (parsedWeights.some(isNaN) || parsedValues.some(isNaN) || isNaN(parsedCapacity)) {
                alert('Please enter valid numbers for weights, values, and capacity.');
                return;
            }

            const maxValue = solveKnapsack(parsedWeights, parsedValues, parsedCapacity);
            setResult(maxValue);
        } catch (error) {
            alert('An error occurred during calculation. Please check your inputs.');
            console.error(error);
        }
    };

    return (
        <div>
            <h1>Knapsack Problem Solver</h1>
            <div>
                <label>Weights (comma-separated): </label>
                <input type="text" value={weights} onChange={(e) => setWeights(e.target.value)} />
            </div>
            <div>
                <label>Values (comma-separated): </label>
                <input type="text" value={values} onChange={(e) => setValues(e.target.value)} />
            </div>
            <div>
                <label>Capacity: </label>
                <input type="number" value={capacity} onChange={(e) => setCapacity(e.target.value)} />
            </div>
            <button onClick={handleCalculate}>Calculate Maximum Value</button>
            {result !== null && <p>Maximum Value: {result}</p>}
        </div>
    );
};

export default KnapsackProblem;

```

--------------------------------

### Convert Markdown to Telegram entities (sync)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/llms-full.txt

Use the convert function to generate plain text and MessageEntity objects for direct use with the Telegram API.

```python
from telebot import TeleBot
from telegramify_markdown import convert

bot = TeleBot("TOKEN")
text, entities = convert("**Bold**, _italic_, and `code`.")
bot.send_message(chat_id, text, entities=[e.to_dict() for e in entities])
```

--------------------------------

### Asynchronous Telegramify

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Asynchronously process Markdown, auto-split long text, and handle different content types like files and photos.

```python
from telegramify_markdown import telegramify
from telegramify_markdown.content import ContentType
results = await telegramify(md, max_message_length=4090)
for item in results:
    if item.content_type == ContentType.TEXT:
        bot.send_message(chat_id, item.text, entities=[e.to_dict() for e in item.entities])
    elif item.content_type == ContentType.FILE:
        bot.send_document(chat_id, (item.file_name, item.file_data))
    elif item.content_type == ContentType.PHOTO:
        bot.send_photo(chat_id, (item.file_name, item.file_data))
```

--------------------------------

### markdownify(content, *, latex_escape=True)

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

Converts Markdown directly to a Telegram MarkdownV2 string.

```APIDOC
## markdownify(content, *, latex_escape=True)

### Description
Synchronous function that converts Markdown directly to a Telegram MarkdownV2 string. Equivalent to entities_to_markdownv2(*convert(content)).

### Parameters
- **content** (str) - Required - Raw Markdown text
- **latex_escape** (bool) - Optional (Default: True) - Convert LaTeX to Unicode

### Response
- **str** - The converted MarkdownV2 string.
```

--------------------------------

### React Knapsack Problem UI

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_longtext.md

This React component provides a user interface for the Knapsack problem. It includes input fields for weights, values, and capacity, a button to trigger the calculation, and displays the resulting maximum value. It utilizes a dynamic programming function for the calculation.

```javascript
import React, { useState } from 'react';

const KnapsackProblem = () => {
    const [weights, setWeights] = useState('');
    const [values, setValues] = useState('');
    const [capacity, setCapacity] = useState('');
    const [result, setResult] = useState(null);

    const solveKnapsack = (W, wt, val, n) => {
        const dp = Array(n + 1).fill(0).map(() => Array(W + 1).fill(0));

        for (let i = 0; i <= n; i++) {
            for (let w = 0; w <= W; w++) {
                if (i === 0 || w === 0) {
                    dp[i][w] = 0;
                } else if (wt[i - 1] <= w) {
                    dp[i][w] = Math.max(val[i - 1] + dp[i - 1][w - wt[i - 1]], dp[i - 1][w]);
                } else {
                    dp[i][w] = dp[i - 1][w];
                }
            }
        }
        return dp[n][W];
    };

    const handleCalculate = () => {
        try {
            const weightsArray = weights.split(',').map(Number);
            const valuesArray = values.split(',').map(Number);
            const capacityNum = Number(capacity);
            const n = weightsArray.length;

            if (weightsArray.length !== valuesArray.length) {
                alert('Weights and values arrays must have the same length.');
                return;
            }

            if (weightsArray.some(isNaN) || valuesArray.some(isNaN) || isNaN(capacityNum)) {
                alert('Please enter valid numbers for weights, values, and capacity.');
                return;
            }

            const maxValue = solveKnapsack(capacityNum, weightsArray, valuesArray, n);
            setResult(maxValue);
        } catch (error) {
            console.error('Error calculating knapsack:', error);
            alert('An error occurred during calculation. Please check your inputs.');
        }
    };

    return (
        <div>
            <h1>Knapsack Problem Solver</h1>
            <div>
                <label>Weights (comma-separated): </label>
                <input type="text" value={weights} onChange={(e) => setWeights(e.target.value)} />
            </div>
            <div>
                <label>Values (comma-separated): </label>
                <input type="text" value={values} onChange={(e) => setValues(e.target.value)} />
            </div>
            <div>
                <label>Capacity: </label>
                <input type="text" value={capacity} onChange={(e) => setCapacity(e.target.value)} />
            </div>
            <button onClick={handleCalculate}>Calculate Maximum Value</button>
            {result !== null && <p>Maximum Value: {result}</p>}
        </div>
    );
};

export default KnapsackProblem;

```

--------------------------------

### Manually Split Entities with split_entities()

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/README.md

If `convert()` is used and manual splitting of long output is required, `split_entities()` can be used to chunk the text and entities based on a maximum UTF-16 length.

```python
from telegramify_markdown import convert, split_entities

text, entities = convert(long_markdown)

for chunk_text, chunk_entities in split_entities(text, entities, max_utf16_len=4096):
    bot.send_message(
        chat_id,
        chunk_text,
        entities=[e.to_dict() for e in chunk_entities],
    )
```

--------------------------------

### Pre-formatted Code Block

Source: https://github.com/sudoskys/telegramify-markdown/blob/main/playground/t_text.md

A standard pre-formatted code block.

```text
pre-formatted fixed-width code block
```
Tokens:
Raw