How to split long message?

[lifr0m]

I was looking for ready solution for this problem. All I found is this. This doesn't support messages with photos and separates by only new line. Also someone mentioned an error in that answer.

[lifr0m]

I slightly modified that solution so that it better separates the message and supports photos. This splites message and returns list of ready to send messages.

def split_message(msg: str, *, with_photo: bool) -> list[str]:
    """ Splites message into several parts considering telegram limits. """
    parts = []
    while msg:
        # Determine max message length based on
        # `with_photo` and is this the first iteration
        # (we send photo only with first message).
        if parts:
            max_msg_length = 4096
        else:
            if with_photo:
                max_msg_length = 1024
            else:
                max_msg_length = 4096

        if len(msg) <= max_msg_length:
            # Message length fits max message length.
            parts.append(msg)
            break
        else:
            # Cut max message length from `msg`
            # and find new line to cut with it.
            part = msg[:max_msg_length]
            first_ln = part.rfind('\n')

            if first_ln != -1:
                # We found new line. Cut with it excluding it.
                new_part = part[:first_ln]
                parts.append(new_part)
                # Cut `msg` with new part length
                # and also remove new line.
                msg = msg[first_ln + 1:]
            else:
                # We didn't find any new line in message part.
                # Let's try to find at least space to cut with it.
                first_space = part.rfind(' ')

                if first_space != -1:
                    # We found space. Cut with it excluding it.
                    new_part = part[:first_space]
                    parts.append(new_part)
                    # Cut `msg` with new part length
                    # and also remove space.
                    msg = msg[first_space + 1:]
                else:
                    # We didn't find any space break.
                    # Just append new part and cut message
                    # with part's length.
                    parts.append(part)
                    msg = msg[max_msg_length:]

    return parts

[EgorPlehanov]

Modified the code to make it possible to separate messages with HTML markup

The code solves the error of missing opening and closing HTML markup tags in the message
❗Telegram server says - Bad Request: can't parse entities: Can't find end tag corresponding to start tag code

import re
from typing import List, Tuple

def split_message(msg: str, *, with_photo: bool) -> list[str]:
    """
    Splits the text into parts considering Telegram limits.
    """
    parts = []
    while msg:
        # Determining the maximum message length based on
        # with_photo and whether it's the first iteration
        # (photo is sent only with the first message).
        if parts:
            max_msg_length = 4096
        else:
            if with_photo:
                max_msg_length = 1024
            else:
                max_msg_length = 4096

        if len(msg) <= max_msg_length:
            # The message length fits within the maximum allowed.
            parts.append(msg)
            break
        else:
            # Cutting a part of the message with the maximum length from msg
            # and finding a position for a break by a newline character.
            part = msg[:max_msg_length]
            first_ln = part.rfind('\n')

            if first_ln != -1:
                # Found a newline character. Splitting the message by it, excluding the character itself.
                new_part = part[:first_ln]
                parts.append(new_part)
                # Trimming msg to the length of the new part
                # and removing the newline character.
                msg = msg[first_ln + 1:]
            else:
                # No newline character found in the message part.
                # Try to find at least a space for a break.
                first_space = part.rfind(' ')

                if first_space != -1:
                    # Found a space. Splitting the message by it, excluding the space itself.
                    new_part = part[:first_space]
                    parts.append(new_part)
                    # Trimming msg to the length of the new part
                    # and removing the space.
                    msg = msg[first_space + 1:]
                else:
                    # No suitable place for a break found in the message part.
                    # Simply add the current part and trim the message
                    # to its length.
                    parts.append(part)
                    msg = msg[max_msg_length:]
    return parts


def close_tags(
    html: str,
    open_tags: List[str] = None
) -> Tuple[str, List[str]]:
    """
    Closes all opening tags
    Adds missing opening tags
    """
    # Pattern for finding tags considering attributes
    tag_pattern = re.compile(r'<(/?)(\w+)([^>]*)>')
    open_stack = []
    close_queue = []
    close_open_tags = []

    for tag in tag_pattern.finditer(html):
        is_closing_tag = tag.group(1) == '/'
        tag_name = tag.group(2)
        tag_atr = tag.group(3)

        if not is_closing_tag:
            # If it's an opening tag, put it in the stack
            open_stack.insert(0, tag_name)
            close_open_tags.append(f"<{tag_name}{tag_atr}>")

        elif open_stack and open_stack[0] == tag_name:
            # If it's a closing tag and the last opening tag in the stack matches the current closing tag, remove it from the stack
            open_stack.pop(0)
            
        else:
            # If the closing tag has no opening tag, add it to the queue
            close_queue.append(tag_name)

    # Close all unclosed tags
    for tag_name in open_stack:
        html += '</' + tag_name + '>'
    
    if open_tags:
        html = "".join(open_tags) + html
    else:
        # Open all unopened tags
        for tag_name in close_queue:
            html = '<' + tag_name + '>' + html

    return html, close_open_tags[-len(open_stack):]

def split_message_with_tags(
    text: str,
    with_photo: bool = False
) -> list[str]:
    """
    Splits the text into parts considering tags.
    """
    result = split_message(msg = text, with_photo=with_photo)

    result_parts = []
    open_tags = None
    for part in result:
        text, open_tags = close_tags(part, open_tags)
        result_parts.append(text)

    return result_parts

Usage example

very_large_message_with_html_markup = """YOUR MESSAGE"""

text_parts = split_message_with_tags(very_large_message_with_html_markup, True)

await bot.send_document(
    chat_id = config.MAIN_ADMIN_ID.get_secret_value(),
    document = BufferedInputFile(
        file = traceback_buffer,
        filename = "traceback.txt"
    ),
    caption = text_parts[0]
)
for text_part in text_parts[1:]:
    await bot.send_message(
        chat_id = config.MAIN_ADMIN_ID.get_secret_value(),
        text = text_part
    )

[Olegt0rr]

@EgorPlehanov, modified your code a little:

• removed else blocks in favour of early return style (easier to read)
• edited doc strings and comments (used imperative mood)
• (todo) after removing else blocks you can see repeating parts and may reuse it

def split_message(msg: str, *, with_photo: bool) -> list[str]:
    """Split the text into parts considering Telegram limits."""
    parts = []
    while msg:
        # Determine the maximum message length based on
        # with_photo and whether it's the first iteration
        # (photo is sent only with the first message).
        if parts:
            max_msg_length = 4096
        elif with_photo:
            max_msg_length = 1024
        else:
            max_msg_length = 4096

        if len(msg) <= max_msg_length:
            # The message length fits within the maximum allowed.
            parts.append(msg)
            break

        # Cut a part of the message with the maximum length from msg
        # and find a position for a break by a newline character.
        part = msg[:max_msg_length]
        first_ln = part.rfind("\n")

        if first_ln != -1:
            # Newline character found.
            # Split the message by it, excluding the character itself.
            new_part = part[:first_ln]
            parts.append(new_part)

            # Trim msg to the length of the new part
            # and remove the newline character.
            msg = msg[first_ln + 1 :]
            continue

        # No newline character found in the message part.
        # Try to find at least a space for a break.
        first_space = part.rfind(" ")

        if first_space != -1:
            # Space character found. 
            # Split the message by it, excluding the space itself.
            new_part = part[:first_space]
            parts.append(new_part)
            
            # Trimming msg to the length of the new part
            # and removing the space.
            msg = msg[first_space + 1 :]
            continue

        # No suitable place for a break found in the message part.
        # Add the current part and trim the message to its length.
        parts.append(part)
        msg = msg[max_msg_length:]

    return parts