LonamiWebs/Telethon
1
1
Fork 0
mirror of https://github.com/LonamiWebs/Telethon.git synced 2024-11-25 19:03:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add async/await on tl.custom

Browse Source
This commit is contained in:
Lonami Exo 2018-06-10 20:29:57 +02:00
parent 1bde72d375
commit d462b04a9c
4 changed files with 78 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
telethon/tl/custom/dialog.py
View File

@ -88,12 +88,13 @@ class Dialog:
)
self.is_channel = isinstance(self.entity, types.Channel)
def send_message(self, *args, **kwargs):
async def send_message(self, *args, **kwargs):
"""
Sends a message to this dialog. This is just a wrapper around
``client.send_message(dialog.input_entity, *args, **kwargs)``.
"""
return self._client.send_message(self.input_entity, *args, **kwargs)
return await self._client.send_message(
self.input_entity, *args, **kwargs)
def to_dict(self):
return {

35
telethon/tl/custom/draft.py
View File

@ -47,18 +47,18 @@ class Draft:
return cls(client=client, peer=update.peer, draft=update.draft)
@property
def entity(self):
async def entity(self):
"""
The entity that belongs to this dialog (user, chat or channel).
"""
return self._client.get_entity(self._peer)
return await self._client.get_entity(self._peer)
@property
def input_entity(self):
async def input_entity(self):
"""
Input version of the entity.
"""
return self._client.get_input_entity(self._peer)
return await self._client.get_input_entity(self._peer)
@property
def text(self):
@ -83,8 +83,9 @@ class Draft:
"""
return not self._text
def set_message(self, text=None, reply_to=0, parse_mode=Default,
link_preview=None):
async def set_message(
self, text=None, reply_to=0, parse_mode=Default,
link_preview=None):
"""
Changes the draft message on the Telegram servers. The changes are
reflected in this object.
@ -110,8 +111,10 @@ class Draft:
if link_preview is None:
link_preview = self.link_preview
raw_text, entities = self._client._parse_message_text(text, parse_mode)
result = self._client(SaveDraftRequest(
raw_text, entities =\
await self._client._parse_message_text(text, parse_mode)
result = await self._client(SaveDraftRequest(
peer=self._peer,
message=raw_text,
no_webpage=not link_preview,
@ -128,22 +131,22 @@ class Draft:
return result
def send(self, clear=True, parse_mode=Default):
async def send(self, clear=True, parse_mode=Default):
"""
Sends the contents of this draft to the dialog. This is just a
wrapper around ``send_message(dialog.input_entity, *args, **kwargs)``.
"""
self._client.send_message(self._peer, self.text,
reply_to=self.reply_to_msg_id,
link_preview=self.link_preview,
parse_mode=parse_mode,
clear_draft=clear)
await self._client.send_message(
self._peer, self.text, reply_to=self.reply_to_msg_id,
link_preview=self.link_preview, parse_mode=parse_mode,
clear_draft=clear
)
def delete(self):
async def delete(self):
"""
Deletes this draft, and returns ``True`` on success.
"""
return self.set_message(text='')
return await self.set_message(text='')
def to_dict(self):
try:

92
telethon/tl/custom/message.py
View File

@ -134,14 +134,15 @@ class Message:
if isinstance(self.original_message, types.MessageService):
return self.original_message.action
def _reload_message(self):
async def _reload_message(self):
"""
Re-fetches this message to reload the sender and chat entities,
along with their input versions.
"""
try:
chat = self.input_chat if self.is_channel else None
msg = self._client.get_messages(chat, ids=self.original_message.id)
chat = await self.input_chat if self.is_channel else None
msg = await self._client.get_messages(
chat, ids=self.original_message.id)
except ValueError:
return # We may not have the input chat/get message failed
if not msg:
@ -153,7 +154,7 @@ class Message:
self._input_chat = msg._input_chat
@property
def sender(self):
async def sender(self):
"""
This (:tl:`User`) may make an API call the first time to get
the most up to date version of the sender (mostly when the event
@ -163,22 +164,24 @@ class Message:
"""
if self._sender is None:
try:
self._sender = self._client.get_entity(self.input_sender)
self._sender =\
await self._client.get_entity(await self.input_sender)
except ValueError:
self._reload_message()
await self._reload_message()
return self._sender
@property
def chat(self):
async def chat(self):
if self._chat is None:
try:
self._chat = self._client.get_entity(self.input_chat)
self._chat =\
await self._client.get_entity(await self.input_chat)
except ValueError:
self._reload_message()
await self._reload_message()
return self._chat
@property
def input_sender(self):
async def input_sender(self):
"""
This (:tl:`InputPeer`) is the input version of the user who
sent the message. Similarly to `input_chat`, this doesn't have
@ -194,14 +197,14 @@ class Message:
self._input_sender = get_input_peer(self._sender)
else:
try:
self._input_sender = self._client.get_input_entity(
self._input_sender = await self._client.get_input_entity(
self.original_message.from_id)
except ValueError:
self._reload_message()
await self._reload_message()
return self._input_sender
@property
def input_chat(self):
async def input_chat(self):
"""
This (:tl:`InputPeer`) is the input version of the chat where the
message was sent. Similarly to `input_sender`, this doesn't have
@ -214,14 +217,14 @@ class Message:
if self._input_chat is None:
if self._chat is None:
try:
self._chat = self._client.get_input_entity(
self._chat = await self._client.get_input_entity(
self.original_message.to_id)
except ValueError:
# There's a chance that the chat is a recent new dialog.
# The input chat cannot rely on ._reload_message() because
# said method may need the input chat.
target = self.chat_id
for d in self._client.iter_dialogs(100):
async for d in self._client.iter_dialogs(100):
if d.id == target:
self._chat = d.entity
break
@ -383,7 +386,7 @@ class Message:
return self.original_message.out
@property
def reply_message(self):
async def reply_message(self):
"""
The `telethon.tl.custom.message.Message` that this message is replying
to, or ``None``.
@ -394,7 +397,7 @@ class Message:
if self._reply_message is None:
if not self.original_message.reply_to_msg_id:
return None
self._reply_message = self._client.get_messages(
self._reply_message = await self._client.get_messages(
self.input_chat if self.is_channel else None,
ids=self.original_message.reply_to_msg_id
)
@ -402,7 +405,7 @@ class Message:
return self._reply_message
@property
def fwd_from_entity(self):
async def fwd_from_entity(self):
"""
If the :tl:`Message` is a forwarded message, returns the :tl:`User`
or :tl:`Channel` who originally sent the message, or ``None``.
@ -411,32 +414,33 @@ class Message:
if getattr(self.original_message, 'fwd_from', None):
fwd = self.original_message.fwd_from
if fwd.from_id:
self._fwd_from_entity = self._client.get_entity(
fwd.from_id)
self._fwd_from_entity =\
await self._client.get_entity(fwd.from_id)
elif fwd.channel_id:
self._fwd_from_entity = self._client.get_entity(
self._fwd_from_entity = await self._client.get_entity(
get_peer_id(types.PeerChannel(fwd.channel_id)))
return self._fwd_from_entity
def respond(self, *args, **kwargs):
async def respond(self, *args, **kwargs):
"""
Responds to the message (not as a reply). Shorthand for
`telethon.telegram_client.TelegramClient.send_message` with
``entity`` already set.
"""
return self._client.send_message(self.input_chat, *args, **kwargs)
return await self._client.send_message(
await self.input_chat, *args, **kwargs)
def reply(self, *args, **kwargs):
async def reply(self, *args, **kwargs):
"""
Replies to the message (as a reply). Shorthand for
`telethon.telegram_client.TelegramClient.send_message` with
both ``entity`` and ``reply_to`` already set.
"""
kwargs['reply_to'] = self.original_message.id
return self._client.send_message(self.original_message.to_id,
*args, **kwargs)
return await self._client.send_message(
await self.input_chat, *args, **kwargs)
def forward_to(self, *args, **kwargs):
async def forward_to(self, *args, **kwargs):
"""
Forwards the message. Shorthand for
`telethon.telegram_client.TelegramClient.forward_messages` with
@ -447,10 +451,10 @@ class Message:
`telethon.telegram_client.TelegramClient` instance directly.
"""
kwargs['messages'] = self.original_message.id
kwargs['from_peer'] = self.input_chat
return self._client.forward_messages(*args, **kwargs)
kwargs['from_peer'] = await self.input_chat
return await self._client.forward_messages(*args, **kwargs)
def edit(self, *args, **kwargs):
async def edit(self, *args, **kwargs):
"""
Edits the message iff it's outgoing. Shorthand for
`telethon.telegram_client.TelegramClient.edit_message` with
@ -468,10 +472,10 @@ class Message:
if self.original_message.to_id.user_id != me.user_id:
return None
return self._client.edit_message(
self.input_chat, self.original_message, *args, **kwargs)
return await self._client.edit_message(
await self.input_chat, self.original_message, *args, **kwargs)
def delete(self, *args, **kwargs):
async def delete(self, *args, **kwargs):
"""
Deletes the message. You're responsible for checking whether you
have the permission to do so, or to except the error otherwise.
@ -483,17 +487,17 @@ class Message:
this `delete` method. Use a
`telethon.telegram_client.TelegramClient` instance directly.
"""
return self._client.delete_messages(
self.input_chat, [self.original_message], *args, **kwargs)
return await self._client.delete_messages(
await self.input_chat, [self.original_message], *args, **kwargs)
def download_media(self, *args, **kwargs):
async def download_media(self, *args, **kwargs):
"""
Downloads the media contained in the message, if any.
`telethon.telegram_client.TelegramClient.download_media` with
the ``message`` already set.
"""
return self._client.download_media(self.original_message,
*args, **kwargs)
return await self._client.download_media(
self.original_message, *args, **kwargs)
def get_entities_text(self):
"""
@ -504,7 +508,7 @@ class Message:
self.original_message.entities)
return list(zip(self.original_message.entities, texts))
def click(self, i=None, j=None, *, text=None, filter=None):
async def click(self, i=None, j=None, *, text=None, filter=None):
"""
Clicks the inline keyboard button of the message, if any.
@ -557,25 +561,25 @@ class Message:
if callable(text):
for button in self._buttons_flat:
if text(button.text):
return button.click()
return await button.click()
else:
for button in self._buttons_flat:
if button.text == text:
return button.click()
return await button.click()
return
if filter is not None:
for button in self._buttons_flat:
if filter(button):
return button.click()
return await button.click()
return
if i is None:
i = 0
if j is None:
return self._buttons_flat[i].click()
return await self._buttons_flat[i].click()
else:
return self._buttons[i][j].click()
return await self._buttons[i][j].click()
class _CustomMessage(Message, types.Message):

14
telethon/tl/custom/messagebutton.py
View File

@ -51,7 +51,7 @@ class MessageButton:
if isinstance(self.button, types.KeyboardButtonUrl):
return self.button.url
def click(self):
async def click(self):
"""
Clicks the inline keyboard button of the message, if any.
@ -59,15 +59,17 @@ class MessageButton:
send the message, switch to inline, or open its URL.
"""
if isinstance(self.button, types.KeyboardButton):
return self._client.send_message(
return await self._client.send_message(
self._chat, self.button.text, reply_to=self._msg_id)
elif isinstance(self.button, types.KeyboardButtonCallback):
return self._client(functions.messages.GetBotCallbackAnswerRequest(
req = functions.messages.GetBotCallbackAnswerRequest(
peer=self._chat, msg_id=self._msg_id, data=self.button.data
), retries=1)
)
return await self._client(req, retries=1)
elif isinstance(self.button, types.KeyboardButtonSwitchInline):
return self._client(functions.messages.StartBotRequest(
req = functions.messages.StartBotRequest(
bot=self._from, peer=self._chat, start_param=self.button.query
), retries=1)
)
return await self._client(req, retries=1)
elif isinstance(self.button, types.KeyboardButtonUrl):
return webbrowser.open(self.button.url)