tessl/pypi-py-telegram-bot-api
Python Telegram bot API library providing a simple, extensible interface for building Telegram bots with complete Bot API support
—
Pending
message-operations.mddocs/
Message Operations
Comprehensive message handling including sending, forwarding, copying, deleting, and editing messages with support for all message types and formatting options.
Capabilities
Text Message Sending
Send text messages with rich formatting, custom keyboards, and reply options.
def send_message(self, chat_id: Union[int, str], text: str,
disable_web_page_preview: Optional[bool] = None,
reply_to_message_id: Optional[int] = None,
reply_markup: Optional[REPLY_MARKUP_TYPES] = None,
parse_mode: Optional[str] = None,
disable_notification: Optional[bool] = None,
timeout: Optional[int] = None,
entities: Optional[List[types.MessageEntity]] = None,
allow_sending_without_reply: Optional[bool] = None) -> types.Message:
"""
Send text messages with formatting and interactive elements.
Parameters:
- chat_id (Union[int, str]): Target chat ID or username
- text (str): Message text (max ~4000 characters)
- disable_web_page_preview (bool, optional): Disable link previews
- reply_to_message_id (int, optional): ID of message to reply to
- reply_markup (REPLY_MARKUP_TYPES, optional): Keyboard markup
- parse_mode (str, optional): 'HTML', 'Markdown', or 'MarkdownV2'
- disable_notification (bool, optional): Send silently
- timeout (int, optional): Request timeout in seconds
- entities (List[MessageEntity], optional): Message entities for formatting
- allow_sending_without_reply (bool, optional): Send even if reply target not found
Returns:
Message: Sent message object
"""
def reply_to(self, message: types.Message, text: str, **kwargs) -> types.Message:
"""
Convenience method to reply to a message.
Parameters:
- message (Message): Message to reply to
- text (str): Reply text
- **kwargs: Additional parameters for send_message
Returns:
Message: Sent reply message
"""Message Forwarding and Copying
Forward or copy messages between chats while preserving or modifying content.
def forward_message(self, chat_id: Union[int, str], from_chat_id: Union[int, str],
message_id: int, disable_notification: Optional[bool] = None,
timeout: Optional[int] = None) -> types.Message:
"""
Forward messages of any kind between chats.
Parameters:
- chat_id (Union[int, str]): Destination chat
- from_chat_id (Union[int, str]): Source chat
- message_id (int): Message ID to forward
- disable_notification (bool, optional): Send silently
- timeout (int, optional): Request timeout
Returns:
Message: Forwarded message
"""
def copy_message(self, chat_id: Union[int, str], from_chat_id: Union[int, str],
message_id: int, caption: Optional[str] = None,
parse_mode: Optional[str] = None,
caption_entities: Optional[List[types.MessageEntity]] = None,
disable_notification: Optional[bool] = None,
reply_to_message_id: Optional[int] = None,
allow_sending_without_reply: Optional[bool] = None,
reply_markup: Optional[REPLY_MARKUP_TYPES] = None,
timeout: Optional[int] = None) -> int:
"""
Copy messages with optional caption modification.
Parameters:
- chat_id (Union[int, str]): Destination chat
- from_chat_id (Union[int, str]): Source chat
- message_id (int): Message ID to copy
- caption (str, optional): New caption for media messages
- parse_mode (str, optional): Caption parsing mode
- caption_entities (List[MessageEntity], optional): Caption entities
- disable_notification (bool, optional): Send silently
- reply_to_message_id (int, optional): Message to reply to
- allow_sending_without_reply (bool, optional): Send if reply target missing
- reply_markup (REPLY_MARKUP_TYPES, optional): Keyboard markup
- timeout (int, optional): Request timeout
Returns:
int: ID of the copied message
"""Message Editing
Edit text content, media, captions, and reply markup of existing messages.
def edit_message_text(self, text: str,
chat_id: Optional[Union[int, str]] = None,
message_id: Optional[int] = None,
inline_message_id: Optional[str] = None,
parse_mode: Optional[str] = None,
entities: Optional[List[types.MessageEntity]] = None,
disable_web_page_preview: Optional[bool] = None,
reply_markup: Optional[REPLY_MARKUP_TYPES] = None) -> Union[types.Message, bool]:
"""
Edit text and game messages.
Parameters:
- text (str): New message text
- chat_id (Union[int, str], optional): Chat ID (required for non-inline)
- message_id (int, optional): Message ID (required for non-inline)
- inline_message_id (str, optional): Inline message ID
- parse_mode (str, optional): Text parsing mode
- entities (List[MessageEntity], optional): Message entities
- disable_web_page_preview (bool, optional): Disable link previews
- reply_markup (REPLY_MARKUP_TYPES, optional): New keyboard markup
Returns:
Union[Message, bool]: Edited message or True for inline messages
"""
def edit_message_caption(self, caption: str,
chat_id: Optional[Union[int, str]] = None,
message_id: Optional[int] = None,
inline_message_id: Optional[str] = None,
parse_mode: Optional[str] = None,
caption_entities: Optional[List[types.MessageEntity]] = None,
reply_markup: Optional[REPLY_MARKUP_TYPES] = None) -> Union[types.Message, bool]:
"""
Edit captions of media messages.
Parameters:
- caption (str): New caption text
- chat_id (Union[int, str], optional): Chat ID
- message_id (int, optional): Message ID
- inline_message_id (str, optional): Inline message ID
- parse_mode (str, optional): Caption parsing mode
- caption_entities (List[MessageEntity], optional): Caption entities
- reply_markup (REPLY_MARKUP_TYPES, optional): New keyboard markup
Returns:
Union[Message, bool]: Edited message or True for inline messages
"""
def edit_message_reply_markup(self, chat_id: Optional[Union[int, str]] = None,
message_id: Optional[int] = None,
inline_message_id: Optional[str] = None,
reply_markup: Optional[REPLY_MARKUP_TYPES] = None) -> Union[types.Message, bool]:
"""
Edit only the reply markup of messages.
Parameters:
- chat_id (Union[int, str], optional): Chat ID
- message_id (int, optional): Message ID
- inline_message_id (str, optional): Inline message ID
- reply_markup (REPLY_MARKUP_TYPES, optional): New keyboard markup
Returns:
Union[Message, bool]: Edited message or True for inline messages
"""Message Deletion
Remove messages from chats with proper error handling.
def delete_message(self, chat_id: Union[int, str], message_id: int,
timeout: Optional[int] = None) -> bool:
"""
Delete messages from chats.
Parameters:
- chat_id (Union[int, str]): Chat containing the message
- message_id (int): ID of message to delete
- timeout (int, optional): Request timeout
Returns:
bool: True on success
Note: Bots can delete outgoing messages in private chats, groups, and supergroups.
Bots granted can_post_messages permissions can delete outgoing messages in channels.
If the bot is an administrator, it can delete any message there.
"""Chat Actions
Send typing indicators and other chat actions to show bot activity.
def send_chat_action(self, chat_id: Union[int, str], action: str,
timeout: Optional[int] = None) -> bool:
"""
Send chat action to indicate bot activity.
Parameters:
- chat_id (Union[int, str]): Target chat
- action (str): Action type ('typing', 'upload_photo', 'record_video',
'upload_video', 'record_audio', 'upload_audio',
'upload_document', 'find_location', 'record_video_note',
'upload_video_note')
- timeout (int, optional): Request timeout
Returns:
bool: True on success
Note: Status is shown for 5 seconds or until a message is sent.
"""Usage Examples
Basic Text Messaging
# Simple text message
bot.send_message(chat_id, "Hello, World!")
# Formatted message with keyboard
from telebot import types
markup = types.InlineKeyboardMarkup()
markup.add(types.InlineKeyboardButton("Click me!", callback_data="button_clicked"))
bot.send_message(
chat_id=chat_id,
text="<b>Bold text</b> and <i>italic text</i>",
parse_mode='HTML',
reply_markup=markup
)Message Forwarding Example
@bot.message_handler(commands=['forward'])
def forward_message_example(message):
# Forward the command message to another chat
target_chat_id = "@your_channel"
forwarded = bot.forward_message(target_chat_id, message.chat.id, message.message_id)
bot.reply_to(message, f"Message forwarded with ID: {forwarded.message_id}")Message Editing Example
@bot.message_handler(commands=['edit'])
def edit_message_example(message):
# Send initial message
sent_msg = bot.reply_to(message, "Initial text")
# Edit after 2 seconds
import time
time.sleep(2)
bot.edit_message_text(
text="Edited text!",
chat_id=sent_msg.chat.id,
message_id=sent_msg.message_id
)Chat Action Example
@bot.message_handler(commands=['typing'])
def show_typing(message):
# Show typing indicator
bot.send_chat_action(message.chat.id, 'typing')
# Simulate processing time
import time
time.sleep(3)
bot.reply_to(message, "Done processing!")Types
class Message:
message_id: int
from_user: Optional[User]
date: int
chat: Chat
content_type: str
text: Optional[str]
entities: Optional[List[MessageEntity]]
caption: Optional[str]
caption_entities: Optional[List[MessageEntity]]
# ... content-specific fields (photo, video, document, etc.)
class MessageEntity:
type: str # 'mention', 'hashtag', 'cashtag', 'bot_command', 'url', etc.
offset: int
length: int
url: Optional[str]
user: Optional[User]
language: Optional[str]
class MessageID:
message_id: int
REPLY_MARKUP_TYPES = Union[InlineKeyboardMarkup, ReplyKeyboardMarkup,
ReplyKeyboardRemove, ForceReply]Install with Tessl CLI
npx tessl i tessl/pypi-py-telegram-bot-api