def parse_deleted_messages(client, update) -> List["types.Message"]:
messages = update.messages
channel_id = getattr(update, "channel_id", None)
parsed_messages = []
for message in messages:
parsed_messages.append(
types.Message(message_id=message,
chat=types.Chat(id=get_channel_id(channel_id),
type="channel",
client=client)
if channel_id is not None else None,
client=client))
return types.List(parsed_messages)
async def send_message(
self,
chat_id: Union[int, str],
text: str,
parse_mode: Optional[str] = object,
entities: List["types.MessageEntity"] = None,
disable_web_page_preview: bool = None,
disable_notification: bool = None,
reply_to_message_id: int = None,
schedule_date: int = None,
reply_markup: Union["types.InlineKeyboardMarkup",
"types.ReplyKeyboardMarkup",
"types.ReplyKeyboardRemove",
"types.ForceReply"] = None
) -> "types.Message":
"""Send text messages.
Parameters:
chat_id (``int`` | ``str``):
Unique identifier (int) or username (str) of the target chat.
For your personal cloud (Saved Messages) you can simply use "me" or "self".
For a contact that exists in your Telegram address book you can use his phone number (str).
text (``str``):
Text of the message to be sent.
parse_mode (``str``, *optional*):
By default, texts are parsed using both Markdown and HTML styles.
You can combine both syntaxes together.
Pass "markdown" or "md" to enable Markdown-style parsing only.
Pass "html" to enable HTML-style parsing only.
Pass None to completely disable style parsing.
entities (List of :obj:`~pyrogram.types.MessageEntity`):
List of special entities that appear in message text, which can be specified instead of *parse_mode*.
disable_web_page_preview (``bool``, *optional*):
Disables link previews for links in this message.
disable_notification (``bool``, *optional*):
Sends the message silently.
Users will receive a notification with no sound.
reply_to_message_id (``int``, *optional*):
If the message is a reply, ID of the original message.
schedule_date (``int``, *optional*):
Date when the message will be automatically sent. Unix time.
reply_markup (:obj:`~pyrogram.types.InlineKeyboardMarkup` | :obj:`~pyrogram.types.ReplyKeyboardMarkup` | :obj:`~pyrogram.types.ReplyKeyboardRemove` | :obj:`~pyrogram.types.ForceReply`, *optional*):
Additional interface options. An object for an inline keyboard, custom reply keyboard,
instructions to remove reply keyboard or to force a reply from the user.
Returns:
:obj:`~pyrogram.types.Message`: On success, the sent text message is returned.
Example:
.. code-block:: python
:emphasize-lines: 2,5,8,11,21-23,26-32
# Simple example
app.send_message("haskell", "Thanks for creating **Pyrogram**!")
# Disable web page previews
app.send_message("me", "https://docs.pyrogram.org", disable_web_page_preview=True)
# Reply to a message using its id
app.send_message("me", "this is a reply", reply_to_message_id=12345)
# Force HTML-only styles for this request only
app.send_message("me", "**not bold**, <i>italic<i>", parse_mode="html")
##
# For bots only, send messages with keyboards attached
##
from pyrogram.types import (
ReplyKeyboardMarkup, InlineKeyboardMarkup, InlineKeyboardButton)
# Send a normal keyboard
app.send_message(
chat_id, "Look at that button!",
reply_markup=ReplyKeyboardMarkup([["Nice!"]]))
# Send an inline keyboard
app.send_message(
chat_id, "These are inline buttons",
reply_markup=InlineKeyboardMarkup(
[
[InlineKeyboardButton("Data", callback_data="hidden_callback_data")],
[InlineKeyboardButton("Docs", url="https://docs.pyrogram.org")]
]))
"""
message, entities = (await
utils.parse_text_entities(self, text, parse_mode,
entities)).values()
r = await self.send(
raw.functions.messages.SendMessage(
peer=await self.resolve_peer(chat_id),
no_webpage=disable_web_page_preview or None,
silent=disable_notification or None,
reply_to_msg_id=reply_to_message_id,
random_id=self.rnd_id(),
schedule_date=schedule_date,
reply_markup=await reply_markup.write(self)
if reply_markup else None,
message=message,
entities=entities))
if isinstance(r, raw.types.UpdateShortSentMessage):
peer = await self.resolve_peer(chat_id)
peer_id = (peer.user_id if isinstance(
peer, raw.types.InputPeerUser) else -peer.chat_id)
return types.Message(message_id=r.id,
chat=types.Chat(id=peer_id,
type="private",
client=self),
text=message,
date=r.date,
outgoing=r.out,
entities=[
types.MessageEntity._parse(
None, entity, {})
for entity in entities
],
client=self)
for i in r.updates:
if isinstance(
i,
(raw.types.UpdateNewMessage, raw.types.UpdateNewChannelMessage,
raw.types.UpdateNewScheduledMessage)):
return await types.Message._parse(
self,
i.message, {i.id: i
for i in r.users}, {i.id: i
for i in r.chats},
is_scheduled=isinstance(
i, raw.types.UpdateNewScheduledMessage))
