def _parse(client, message: Union[raw.types.Message,
raw.types.MessageService], users: dict,
chats: dict, is_chat: bool) -> Optional["Chat"]:
from_id = utils.get_raw_peer_id(message.from_id)
peer_id = utils.get_raw_peer_id(message.peer_id)
chat_id = (peer_id or from_id) if is_chat else (from_id or peer_id)
if isinstance(message.peer_id, raw.types.PeerUser):
return Chat._parse_user_chat(client, users.get(chat_id, None))
if isinstance(message.peer_id, raw.types.PeerChat):
return Chat._parse_chat_chat(client, chats.get(chat_id, None))
return Chat._parse_channel_chat(client, chats.get(chat_id, None))
def _parse(client, message: raw.types.Message or raw.types.MessageService,
users: dict, chats: dict) -> "Chat":
if isinstance(message.peer_id, raw.types.PeerUser):
return Chat._parse_user_chat(
client, users[message.peer_id.user_id if message.
out else utils.get_raw_peer_id(message.from_id)])
if isinstance(message.peer_id, raw.types.PeerChat):
return Chat._parse_chat_chat(client,
chats[message.peer_id.chat_id])
return Chat._parse_channel_chat(client,
chats[message.peer_id.channel_id])
def _parse(client: "pyrogram.Client",
update: "raw.types.UpdateBotChatInviteRequester",
users: Dict[int, "raw.types.User"],
chats: Dict[int, "raw.types.Chat"]) -> "ChatJoinRequest":
chat_id = utils.get_raw_peer_id(update.peer)
return ChatJoinRequest(
chat=types.Chat._parse_chat(client, chats[chat_id]),
from_user=types.User._parse(client, users[update.user_id]),
date=update.date,
bio=update.about,
invite_link=types.ChatInviteLink._parse(client, update.invite,
users),
client=client)
async def _parse(client,
message: raw.types.Message,
users: dict,
chats: dict,
is_scheduled: bool = False):
if message is None:
return None
entities = [
types.MessageEntity._parse(client, entity, users)
for entity in message.entities
]
entities = types.List(filter(lambda x: x is not None, entities))
user = utils.get_raw_peer_id(message.from_id) or utils.get_raw_peer_id(
message.peer_id)
from_user = types.User._parse(client, users.get(user, None))
sender_chat = await types.Chat._parse(client, message, users,
chats) if not from_user else None
reply_markup = message.reply_markup
if reply_markup:
if isinstance(reply_markup, raw.types.ReplyKeyboardForceReply):
reply_markup = types.ForceReply.read(reply_markup)
elif isinstance(reply_markup, raw.types.ReplyKeyboardMarkup):
reply_markup = types.ReplyKeyboardMarkup.read(reply_markup)
elif isinstance(reply_markup, raw.types.ReplyInlineMarkup):
reply_markup = types.InlineKeyboardMarkup.read(reply_markup)
elif isinstance(reply_markup, raw.types.ReplyKeyboardHide):
reply_markup = types.ReplyKeyboardRemove.read(reply_markup)
else:
reply_markup = None
raw_media = message.media
media = None
media_type = None
if raw_media:
if isinstance(raw_media, raw.types.MessageMediaPhoto):
media = types.Photo._parse(client, raw_media.photo,
raw_media.ttl_seconds)
media_type = 'photo'
elif isinstance(raw_media, raw.types.MessageMediaGeo):
media = types.Geo._parse(client, raw_media)
media_type = 'location'
elif isinstance(raw_media, raw.types.MessageMediaContact):
media = types.Contact._parse(client, raw_media)
media_type = 'contact'
elif isinstance(raw_media, raw.types.MessageMediaDocument):
doc = raw_media.document
if isinstance(doc, raw.types.Document):
attributes = {type(i): i for i in doc.attributes}
file_name = getattr(
attributes.get(raw.types.DocumentAttributeFilename,
None), "file_name", None)
if raw.types.DocumentAttributeAudio in attributes:
audio_attributes = attributes[
raw.types.DocumentAttributeAudio]
if audio_attributes.voice:
media = types.Voice._parse(client, doc,
audio_attributes)
media_type = 'voice'
else:
media = types.Audio._parse(client, doc,
audio_attributes,
file_name)
media_type = 'audio'
elif raw.types.DocumentAttributeAnimated in attributes:
video_attributes = attributes.get(
raw.types.DocumentAttributeVideo, None)
media = types.Animation._parse(client, doc,
video_attributes,
file_name)
media_type = 'animation'
elif raw.types.DocumentAttributeVideo in attributes:
video_attributes = attributes[
raw.types.DocumentAttributeVideo]
if video_attributes.round_message:
media = types.VideoNote._parse(
client, doc, video_attributes)
media_type = 'video_note'
else:
media = types.Video._parse(client, doc,
video_attributes,
file_name,
raw_media.ttl_seconds)
media_type = 'video'
elif raw.types.DocumentAttributeSticker in attributes:
media = await types.Sticker._parse(
client, doc,
attributes.get(
raw.types.DocumentAttributeImageSize, None),
attributes[raw.types.DocumentAttributeSticker],
file_name)
media_type = 'sticker'
else:
media = types.Document._parse(client, doc, file_name)
media_type = 'document'
elif isinstance(raw_media, raw.types.MessageMediaWebPage):
if isinstance(raw_media.webpage, raw.types.WebPage):
media = types.WebPage._parse(client, raw_media.webpage)
media_type = 'webpage'
else:
media = None
elif isinstance(raw_media, raw.types.MessageMediaVenue):
media = types.Venue._parse(client, raw_media)
media_type = 'venue'
elif isinstance(raw_media, raw.types.MessageMediaGame):
media = types.Game._parse(client, message)
media_type = 'game'
elif isinstance(raw_media, raw.types.MessageMediaInvoice):
media = types.Invoice._parse(client, raw_media)
media_type = 'invoice'
elif isinstance(raw_media, raw.types.MessageMediaGeoLive):
media = types.GeoLive._parse(client, raw_media)
media_type = 'live_location'
elif isinstance(raw_media, raw.types.MessageMediaPoll):
media = types.Poll._parse(client, raw_media)
media_type = 'poll'
elif isinstance(raw_media, raw.types.MessageMediaDice):
media = types.Dice._parse(client, raw_media)
media_type = 'dice'
else:
media = None
return MessageNormal(
client=client,
edit_date=getattr(message, 'edit_date', None),
is_outgoing=getattr(message, 'out', None),
mentioned=getattr(message, 'mentioned', None),
media_unread=getattr(message, 'media_unread', None),
is_silent=getattr(message, 'silent', None),
is_post=getattr(message, 'post', None),
from_scheduled=getattr(message, 'from_scheduled', None),
is_scheduled=is_scheduled,
legacy=getattr(message, 'legacy', None),
edit_hide=getattr(message, 'edit_hide', None),
is_pinned=getattr(message, 'pinned', None),
media_group_id=getattr(message, 'grouped_id', None),
from_user=from_user,
sender_chat=sender_chat,
forward_header=await types.MessageForwardHeader._parse(
client, getattr(message, 'fwd_from', None), users, chats),
via_bot=users.get(message.via_bot_id, None) if getattr(
message, 'via_bot_id', None) else None,
reply_header=types.MessageReplyHeader._parse(
client, getattr(message, 'reply_to', None), users, chats),
text=types.Str(message.message).init(entities) or None,
media=media,
media_type=media_type,
reply_markup=reply_markup,
entities=entities,
views=await
types.MessageViews._parse_from_message(client, message.id, message,
users, chats),
restrictions=types.List([
types.Restriction._parse(restriction)
for restriction in getattr(message, 'restrictions', [])
]) or None,
)
def _parse_action(client, service: raw.types.MessageService, users: dict):
return GameHighScore(user=types.User._parse(
client, users[utils.get_raw_peer_id(service.from_id
or service.peer_id)]),
score=service.action.score,
client=client)
async def get_dialogs(
self,
offset_date: int = 0,
limit: int = 100,
pinned_only: bool = False
) -> List["types.Dialog"]:
"""Get a chunk of the user's dialogs.
You can get up to 100 dialogs at once.
For a more convenient way of getting a user's dialogs see :meth:`~pyrogram.Client.iter_dialogs`.
Parameters:
offset_date (``int``):
The offset date in Unix time taken from the top message of a :obj:`~pyrogram.types.Dialog`.
Defaults to 0. Valid for non-pinned dialogs only.
limit (``str``, *optional*):
Limits the number of dialogs to be retrieved.
Defaults to 100. Valid for non-pinned dialogs only.
pinned_only (``bool``, *optional*):
Pass True if you want to get only pinned dialogs.
Defaults to False.
Returns:
List of :obj:`~pyrogram.types.Dialog`: On success, a list of dialogs is returned.
Example:
.. code-block:: python
# Get first 100 dialogs
app.get_dialogs()
# Get pinned dialogs
app.get_dialogs(pinned_only=True)
"""
if pinned_only:
r = await self.send(
raw.functions.messages.GetPinnedDialogs(folder_id=0),
sleep_threshold=60
)
else:
r = await self.send(
raw.functions.messages.GetDialogs(
offset_date=offset_date,
offset_id=0,
offset_peer=raw.types.InputPeerEmpty(),
limit=limit,
hash=0,
exclude_pinned=True
),
sleep_threshold=60
)
users = {i.id: i for i in r.users}
chats = {i.id: i for i in r.chats}
messages = {}
for message in r.messages:
peer_id = message.peer_id
if isinstance(peer_id, raw.types.PeerUser):
if message.out:
chat_id = peer_id.user_id
else:
chat_id = utils.get_raw_peer_id(message.from_id)
else:
chat_id = utils.get_peer_id(peer_id)
messages[chat_id] = await types.Message._parse(self, message, users, chats)
parsed_dialogs = []
for dialog in r.dialogs:
if not isinstance(dialog, raw.types.Dialog):
continue
parsed_dialogs.append(types.Dialog._parse(self, dialog, messages, users, chats))
return types.List(parsed_dialogs)
def _parse(
client: "pyrogram.Client",
member: Union["raw.base.ChatParticipant", "raw.base.ChannelParticipant"],
users: Dict[int, "raw.base.User"],
chats: Dict[int, "raw.base.Chat"]
) -> "ChatMember":
# Chat participants
if isinstance(member, raw.types.ChatParticipant):
return ChatMember(
status=enums.ChatMemberStatus.MEMBER,
user=types.User._parse(client, users[member.user_id]),
joined_date=utils.timestamp_to_datetime(member.date),
invited_by=types.User._parse(client, users[member.inviter_id]),
client=client
)
elif isinstance(member, raw.types.ChatParticipantAdmin):
return ChatMember(
status=enums.ChatMemberStatus.ADMINISTRATOR,
user=types.User._parse(client, users[member.user_id]),
joined_date=utils.timestamp_to_datetime(member.date),
invited_by=types.User._parse(client, users[member.inviter_id]),
client=client
)
elif isinstance(member, raw.types.ChatParticipantCreator):
return ChatMember(
status=enums.ChatMemberStatus.OWNER,
user=types.User._parse(client, users[member.user_id]),
client=client
)
# Channel participants
if isinstance(member, raw.types.ChannelParticipant):
return ChatMember(
status=enums.ChatMemberStatus.MEMBER,
user=types.User._parse(client, users[member.user_id]),
joined_date=utils.timestamp_to_datetime(member.date),
client=client
)
elif isinstance(member, raw.types.ChannelParticipantAdmin):
return ChatMember(
status=enums.ChatMemberStatus.ADMINISTRATOR,
user=types.User._parse(client, users[member.user_id]),
joined_date=utils.timestamp_to_datetime(member.date),
promoted_by=types.User._parse(client, users[member.promoted_by]),
invited_by=(
types.User._parse(client, users[member.inviter_id])
if member.inviter_id else None
),
custom_title=member.rank,
can_be_edited=member.can_edit,
privileges=types.ChatPrivileges._parse(member.admin_rights),
client=client
)
elif isinstance(member, raw.types.ChannelParticipantBanned):
peer = member.peer
peer_id = utils.get_raw_peer_id(peer)
user = (
types.User._parse(client, users[peer_id])
if isinstance(peer, raw.types.PeerUser) else None
)
chat = (
types.Chat._parse_chat(client, chats[peer_id])
if not isinstance(peer, raw.types.PeerUser) else None
)
return ChatMember(
status=(
enums.ChatMemberStatus.BANNED
if member.banned_rights.view_messages
else enums.ChatMemberStatus.RESTRICTED
),
user=user,
chat=chat,
until_date=utils.timestamp_to_datetime(member.banned_rights.until_date),
joined_date=utils.timestamp_to_datetime(member.date),
is_member=not member.left,
restricted_by=types.User._parse(client, users[member.kicked_by]),
permissions=types.ChatPermissions._parse(member.banned_rights),
client=client
)
elif isinstance(member, raw.types.ChannelParticipantCreator):
return ChatMember(
status=enums.ChatMemberStatus.OWNER,
user=types.User._parse(client, users[member.user_id]),
custom_title=member.rank,
privileges=types.ChatPrivileges._parse(member.admin_rights),
client=client
)
elif isinstance(member, raw.types.ChannelParticipantLeft):
peer = member.peer
peer_id = utils.get_raw_peer_id(peer)
user = (
types.User._parse(client, users[peer_id])
if isinstance(peer, raw.types.PeerUser) else None
)
chat = (
types.Chat._parse_chat(client, chats[peer_id])
if not isinstance(peer, raw.types.PeerUser) else None
)
return ChatMember(
status=enums.ChatMemberStatus.LEFT,
user=user,
chat=chat,
client=client
)
elif isinstance(member, raw.types.ChannelParticipantSelf):
return ChatMember(
status=enums.ChatMemberStatus.MEMBER,
user=types.User._parse(client, users[member.user_id]),
joined_date=utils.timestamp_to_datetime(member.date),
invited_by=types.User._parse(client, users[member.inviter_id]),
client=client
)