mirror of
https://github.com/LonamiWebs/Telethon.git
synced 2024-09-21 19:28:54 +03:00
1012 lines
38 KiB
Python
1012 lines
38 KiB
Python
import os
|
|
from datetime import datetime, timedelta
|
|
from mimetypes import guess_type
|
|
|
|
try:
|
|
import socks
|
|
except ImportError:
|
|
socks = None
|
|
|
|
from . import TelegramBareClient
|
|
from . import helpers, utils
|
|
from .errors import (
|
|
RPCError, UnauthorizedError, InvalidParameterError, PhoneCodeEmptyError,
|
|
PhoneCodeExpiredError, PhoneCodeHashEmptyError, PhoneCodeInvalidError
|
|
)
|
|
from .network import ConnectionMode
|
|
from .tl import TLObject
|
|
from .tl.custom import Draft
|
|
from .tl.entity_database import EntityDatabase
|
|
from .tl.functions.account import (
|
|
GetPasswordRequest
|
|
)
|
|
from .tl.functions.auth import (
|
|
CheckPasswordRequest, LogOutRequest, SendCodeRequest, SignInRequest,
|
|
SignUpRequest, ImportBotAuthorizationRequest
|
|
)
|
|
from .tl.functions.contacts import (
|
|
GetContactsRequest, ResolveUsernameRequest
|
|
)
|
|
from .tl.functions.messages import (
|
|
GetDialogsRequest, GetHistoryRequest, ReadHistoryRequest, SendMediaRequest,
|
|
SendMessageRequest, GetChatsRequest,
|
|
GetAllDraftsRequest)
|
|
|
|
from .tl.functions import channels
|
|
from .tl.functions import messages
|
|
|
|
from .tl.functions.users import (
|
|
GetUsersRequest
|
|
)
|
|
from .tl.functions.channels import (
|
|
GetChannelsRequest
|
|
)
|
|
from .tl.types import (
|
|
DocumentAttributeAudio, DocumentAttributeFilename,
|
|
InputDocumentFileLocation, InputFileLocation,
|
|
InputMediaUploadedDocument, InputMediaUploadedPhoto, InputPeerEmpty,
|
|
Message, MessageMediaContact, MessageMediaDocument, MessageMediaPhoto,
|
|
InputUserSelf, UserProfilePhoto, ChatPhoto, UpdateMessageID,
|
|
UpdateNewChannelMessage, UpdateNewMessage, UpdateShortSentMessage,
|
|
PeerUser, InputPeerUser, InputPeerChat, InputPeerChannel)
|
|
from .tl.types.messages import DialogsSlice
|
|
|
|
|
|
class TelegramClient(TelegramBareClient):
|
|
"""Full featured TelegramClient meant to extend the basic functionality -
|
|
|
|
As opposed to the TelegramBareClient, this one features downloading
|
|
media from different data centers, starting a second thread to
|
|
handle updates, and some very common functionality.
|
|
"""
|
|
|
|
# region Initialization
|
|
|
|
def __init__(self, session, api_id, api_hash,
|
|
connection_mode=ConnectionMode.TCP_FULL,
|
|
proxy=None,
|
|
update_workers=None,
|
|
timeout=timedelta(seconds=5),
|
|
spawn_read_thread=True,
|
|
**kwargs):
|
|
"""Initializes the Telegram client with the specified API ID and Hash.
|
|
|
|
Session can either be a `str` object (filename for the .session)
|
|
or it can be a `Session` instance (in which case list_sessions()
|
|
would probably not work). Pass 'None' for it to be a temporary
|
|
session - remember to '.log_out()'!
|
|
|
|
The 'connection_mode' should be any value under ConnectionMode.
|
|
This will only affect how messages are sent over the network
|
|
and how much processing is required before sending them.
|
|
|
|
The integer 'update_workers' represents depending on its value:
|
|
is None: Updates will *not* be stored in memory.
|
|
= 0: Another thread is responsible for calling self.updates.poll()
|
|
> 0: 'update_workers' background threads will be spawned, any
|
|
any of them will invoke all the self.updates.handlers.
|
|
|
|
If 'spawn_read_thread', a background thread will be started once
|
|
an authorized user has been logged in to Telegram to read items
|
|
(such as updates and responses) from the network as soon as they
|
|
occur, which will speed things up.
|
|
|
|
If you don't want to spawn any additional threads, pending updates
|
|
will be read and processed accordingly after invoking a request
|
|
and not immediately. This is useful if you don't care about updates
|
|
at all and have set 'update_workers=None'.
|
|
|
|
If more named arguments are provided as **kwargs, they will be
|
|
used to update the Session instance. Most common settings are:
|
|
device_model = platform.node()
|
|
system_version = platform.system()
|
|
app_version = TelegramClient.__version__
|
|
lang_code = 'en'
|
|
system_lang_code = lang_code
|
|
report_errors = True
|
|
"""
|
|
super().__init__(
|
|
session, api_id, api_hash,
|
|
connection_mode=connection_mode,
|
|
proxy=proxy,
|
|
update_workers=update_workers,
|
|
spawn_read_thread=spawn_read_thread,
|
|
timeout=timeout,
|
|
**kwargs
|
|
)
|
|
|
|
# Some fields to easy signing in
|
|
self._phone_code_hash = None
|
|
self._phone = None
|
|
|
|
# endregion
|
|
|
|
# region Telegram requests functions
|
|
|
|
# region Authorization requests
|
|
|
|
def send_code_request(self, phone):
|
|
"""Sends a code request to the specified phone number"""
|
|
phone = EntityDatabase.parse_phone(phone) or self._phone
|
|
result = self(SendCodeRequest(phone, self.api_id, self.api_hash))
|
|
self._phone = phone
|
|
self._phone_code_hash = result.phone_code_hash
|
|
return result
|
|
|
|
def sign_in(self, phone=None, code=None,
|
|
password=None, bot_token=None, phone_code_hash=None):
|
|
"""Completes the sign in process with the phone number + code pair.
|
|
|
|
If no phone or code is provided, then the sole password will be used.
|
|
The password should be used after a normal authorization attempt
|
|
has happened and an SessionPasswordNeededError was raised.
|
|
|
|
If you're calling .sign_in() on two completely different clients
|
|
(for example, through an API that creates a new client per phone),
|
|
you must first call .sign_in(phone) to receive the code, and then
|
|
with the result such method results, call
|
|
.sign_in(phone, code, phone_code_hash=result.phone_code_hash).
|
|
|
|
If this is done on the same client, the client will fill said values
|
|
for you.
|
|
|
|
To login as a bot, only `bot_token` should be provided.
|
|
This should equal to the bot access hash provided by
|
|
https://t.me/BotFather during your bot creation.
|
|
|
|
If the login succeeds, the logged in user is returned.
|
|
"""
|
|
|
|
if phone and not code:
|
|
return self.send_code_request(phone)
|
|
elif code:
|
|
phone = EntityDatabase.parse_phone(phone) or self._phone
|
|
phone_code_hash = phone_code_hash or self._phone_code_hash
|
|
if not phone:
|
|
raise ValueError(
|
|
'Please make sure to call send_code_request first.'
|
|
)
|
|
if not phone_code_hash:
|
|
raise ValueError('You also need to provide a phone_code_hash.')
|
|
|
|
try:
|
|
if isinstance(code, int):
|
|
code = str(code)
|
|
|
|
result = self(SignInRequest(phone, phone_code_hash, code))
|
|
|
|
except (PhoneCodeEmptyError, PhoneCodeExpiredError,
|
|
PhoneCodeHashEmptyError, PhoneCodeInvalidError):
|
|
return None
|
|
elif password:
|
|
salt = self(GetPasswordRequest()).current_salt
|
|
result = self(CheckPasswordRequest(
|
|
helpers.get_password_hash(password, salt)
|
|
))
|
|
elif bot_token:
|
|
result = self(ImportBotAuthorizationRequest(
|
|
flags=0, bot_auth_token=bot_token,
|
|
api_id=self.api_id, api_hash=self.api_hash
|
|
))
|
|
else:
|
|
raise ValueError(
|
|
'You must provide a phone and a code the first time, '
|
|
'and a password only if an RPCError was raised before.'
|
|
)
|
|
|
|
self._set_connected_and_authorized()
|
|
return result.user
|
|
|
|
def sign_up(self, code, first_name, last_name=''):
|
|
"""Signs up to Telegram. Make sure you sent a code request first!"""
|
|
result = self(SignUpRequest(
|
|
phone_number=self._phone,
|
|
phone_code_hash=self._phone_code_hash,
|
|
phone_code=code,
|
|
first_name=first_name,
|
|
last_name=last_name
|
|
))
|
|
|
|
self._set_connected_and_authorized()
|
|
return result.user
|
|
|
|
def log_out(self):
|
|
"""Logs out and deletes the current session.
|
|
Returns True if everything went okay."""
|
|
try:
|
|
self(LogOutRequest())
|
|
except RPCError:
|
|
return False
|
|
|
|
self.disconnect()
|
|
self.session.delete()
|
|
self.session = None
|
|
return True
|
|
|
|
def get_me(self):
|
|
"""Gets "me" (the self user) which is currently authenticated,
|
|
or None if the request fails (hence, not authenticated)."""
|
|
try:
|
|
return self(GetUsersRequest([InputUserSelf()]))[0]
|
|
except UnauthorizedError:
|
|
return None
|
|
|
|
# endregion
|
|
|
|
# region Dialogs ("chats") requests
|
|
|
|
def get_dialogs(self,
|
|
limit=10,
|
|
offset_date=None,
|
|
offset_id=0,
|
|
offset_peer=InputPeerEmpty()):
|
|
"""Returns a tuple of lists ([dialogs], [entities])
|
|
with at least 'limit' items each unless all dialogs were consumed.
|
|
|
|
If `limit` is None, all dialogs will be retrieved (from the given
|
|
offset) will be retrieved.
|
|
|
|
The `entities` represent the user, chat or channel
|
|
corresponding to that dialog. If it's an integer, not
|
|
all dialogs may be retrieved at once.
|
|
"""
|
|
if limit is None:
|
|
limit = float('inf')
|
|
|
|
dialogs = {} # Use peer id as identifier to avoid dupes
|
|
messages = {} # Used later for sorting TODO also return these?
|
|
entities = {}
|
|
while len(dialogs) < limit:
|
|
need = limit - len(dialogs)
|
|
r = self(GetDialogsRequest(
|
|
offset_date=offset_date,
|
|
offset_id=offset_id,
|
|
offset_peer=offset_peer,
|
|
limit=need if need < float('inf') else 0
|
|
))
|
|
if not r.dialogs:
|
|
break
|
|
|
|
for d in r.dialogs:
|
|
dialogs[utils.get_peer_id(d.peer, True)] = d
|
|
for m in r.messages:
|
|
messages[m.id] = m
|
|
|
|
# We assume users can't have the same ID as a chat
|
|
for u in r.users:
|
|
entities[u.id] = u
|
|
for c in r.chats:
|
|
entities[c.id] = c
|
|
|
|
if not isinstance(r, DialogsSlice):
|
|
# Don't enter next iteration if we already got all
|
|
break
|
|
|
|
offset_date = r.messages[-1].date
|
|
offset_peer = utils.find_user_or_chat(
|
|
r.dialogs[-1].peer, entities, entities
|
|
)
|
|
offset_id = r.messages[-1].id & 4294967296 # Telegram/danog magic
|
|
|
|
# Sort by message date. Windows will raise if timestamp is 0,
|
|
# so we need to set at least one day ahead while still being
|
|
# the smallest date possible.
|
|
no_date = datetime.fromtimestamp(86400)
|
|
ds = list(sorted(
|
|
dialogs.values(),
|
|
key=lambda d: getattr(messages[d.top_message], 'date', no_date)
|
|
))
|
|
if limit < float('inf'):
|
|
ds = ds[:limit]
|
|
return (
|
|
ds,
|
|
[utils.find_user_or_chat(d.peer, entities, entities) for d in ds]
|
|
)
|
|
|
|
def get_drafts(self): # TODO: Ability to provide a `filter`
|
|
"""
|
|
Gets all open draft messages.
|
|
|
|
Returns a list of custom `Draft` objects that are easy to work with: You can call
|
|
`draft.set_message('text')` to change the message, or delete it through `draft.delete()`.
|
|
|
|
:return List[telethon.tl.custom.Draft]: A list of open drafts
|
|
"""
|
|
response = self(GetAllDraftsRequest())
|
|
self.session.process_entities(response)
|
|
self.session.generate_sequence(response.seq)
|
|
drafts = [Draft._from_update(self, u) for u in response.updates]
|
|
return drafts
|
|
|
|
def send_message(self,
|
|
entity,
|
|
message,
|
|
reply_to=None,
|
|
link_preview=True):
|
|
"""Sends a message to the given entity (or input peer)
|
|
and returns the sent message as a Telegram object.
|
|
|
|
If 'reply_to' is set to either a message or a message ID,
|
|
the sent message will be replying to such message.
|
|
"""
|
|
entity = self.get_input_entity(entity)
|
|
request = SendMessageRequest(
|
|
peer=entity,
|
|
message=message,
|
|
entities=[],
|
|
no_webpage=not link_preview,
|
|
reply_to_msg_id=self._get_reply_to(reply_to)
|
|
)
|
|
result = self(request)
|
|
if isinstance(result, UpdateShortSentMessage):
|
|
return Message(
|
|
id=result.id,
|
|
to_id=entity,
|
|
message=message,
|
|
date=result.date,
|
|
out=result.out,
|
|
media=result.media,
|
|
entities=result.entities
|
|
)
|
|
|
|
# Telegram seems to send updateMessageID first, then updateNewMessage,
|
|
# however let's not rely on that just in case.
|
|
msg_id = None
|
|
for update in result.updates:
|
|
if isinstance(update, UpdateMessageID):
|
|
if update.random_id == request.random_id:
|
|
msg_id = update.id
|
|
break
|
|
|
|
for update in result.updates:
|
|
if isinstance(update, (UpdateNewChannelMessage, UpdateNewMessage)):
|
|
if update.message.id == msg_id:
|
|
return update.message
|
|
|
|
return None # Should not happen
|
|
|
|
def delete_messages(self, entity, message_ids, revoke=True):
|
|
"""
|
|
Deletes a message from a chat, optionally "for everyone" with argument
|
|
`revoke` set to `True`.
|
|
|
|
The `revoke` argument has no effect for Channels and Supergroups,
|
|
where it inherently behaves as being `True`.
|
|
|
|
Note: The `entity` argument can be `None` for normal chats, but it's
|
|
mandatory to delete messages from Channels and Supergroups. It is also
|
|
possible to supply a chat_id which will be automatically resolved to
|
|
the right type of InputPeer.
|
|
|
|
:param entity: ID or Entity of the chat
|
|
:param list message_ids: ID(s) or `Message` object(s) of the message(s) to delete
|
|
:param revoke: Delete the message for everyone or just this client
|
|
:returns .messages.AffectedMessages: Messages affected by deletion.
|
|
"""
|
|
|
|
if not isinstance(message_ids, list):
|
|
message_ids = [message_ids]
|
|
message_ids = [m.id if isinstance(m, Message) else int(m) for m in message_ids]
|
|
|
|
if entity is None:
|
|
return self(messages.DeleteMessagesRequest(message_ids, revoke=revoke))
|
|
|
|
entity = self.get_input_entity(entity)
|
|
|
|
if isinstance(entity, InputPeerChannel):
|
|
return self(channels.DeleteMessagesRequest(entity, message_ids))
|
|
else:
|
|
return self(messages.DeleteMessagesRequest(message_ids, revoke=revoke))
|
|
|
|
def get_message_history(self,
|
|
entity,
|
|
limit=20,
|
|
offset_date=None,
|
|
offset_id=0,
|
|
max_id=0,
|
|
min_id=0,
|
|
add_offset=0):
|
|
"""
|
|
Gets the message history for the specified entity
|
|
|
|
:param entity: The entity from whom to retrieve the message history
|
|
:param limit: Number of messages to be retrieved
|
|
:param offset_date: Offset date (messages *previous* to this date will be retrieved)
|
|
:param offset_id: Offset message ID (only messages *previous* to the given ID will be retrieved)
|
|
:param max_id: All the messages with a higher (newer) ID or equal to this will be excluded
|
|
:param min_id: All the messages with a lower (older) ID or equal to this will be excluded
|
|
:param add_offset: Additional message offset (all of the specified offsets + this offset = older messages)
|
|
|
|
:return: A tuple containing total message count and two more lists ([messages], [senders]).
|
|
Note that the sender can be null if it was not found!
|
|
|
|
The entity may be a phone or an username at the expense of
|
|
some performance loss.
|
|
"""
|
|
result = self(GetHistoryRequest(
|
|
peer=self.get_input_entity(entity),
|
|
limit=limit,
|
|
offset_date=offset_date,
|
|
offset_id=offset_id,
|
|
max_id=max_id,
|
|
min_id=min_id,
|
|
add_offset=add_offset
|
|
))
|
|
|
|
# The result may be a messages slice (not all messages were retrieved)
|
|
# or simply a messages TLObject. In the later case, no "count"
|
|
# attribute is specified, so the total messages count is simply
|
|
# the count of retrieved messages
|
|
total_messages = getattr(result, 'count', len(result.messages))
|
|
|
|
# Iterate over all the messages and find the sender User
|
|
entities = [
|
|
utils.find_user_or_chat(m.from_id, result.users, result.chats)
|
|
if m.from_id is not None else
|
|
utils.find_user_or_chat(m.to_id, result.users, result.chats)
|
|
|
|
for m in result.messages
|
|
]
|
|
|
|
return total_messages, result.messages, entities
|
|
|
|
def send_read_acknowledge(self, entity, messages=None, max_id=None):
|
|
"""Sends a "read acknowledge" (i.e., notifying the given peer that we've
|
|
read their messages, also known as the "double check").
|
|
|
|
Either a list of messages (or a single message) can be given,
|
|
or the maximum message ID (until which message we want to send the read acknowledge).
|
|
|
|
Returns an AffectedMessages TLObject
|
|
|
|
The entity may be a phone or an username at the expense of
|
|
some performance loss.
|
|
"""
|
|
if max_id is None:
|
|
if not messages:
|
|
raise InvalidParameterError(
|
|
'Either a message list or a max_id must be provided.')
|
|
|
|
if isinstance(messages, list):
|
|
max_id = max(msg.id for msg in messages)
|
|
else:
|
|
max_id = messages.id
|
|
|
|
return self(ReadHistoryRequest(
|
|
peer=self.get_input_entity(entity),
|
|
max_id=max_id
|
|
))
|
|
|
|
@staticmethod
|
|
def _get_reply_to(reply_to):
|
|
"""Sanitizes the 'reply_to' parameter a user may send"""
|
|
if reply_to is None:
|
|
return None
|
|
|
|
if isinstance(reply_to, int):
|
|
return reply_to
|
|
|
|
if isinstance(reply_to, TLObject) and \
|
|
type(reply_to).SUBCLASS_OF_ID == 0x790009e3:
|
|
# hex(crc32(b'Message')) = 0x790009e3
|
|
return reply_to.id
|
|
|
|
raise ValueError('Invalid reply_to type: ', type(reply_to))
|
|
|
|
# endregion
|
|
|
|
# region Uploading files
|
|
|
|
def send_file(self, entity, file, caption='',
|
|
force_document=False, progress_callback=None,
|
|
reply_to=None,
|
|
attributes=None,
|
|
**kwargs):
|
|
"""Sends a file to the specified entity.
|
|
The file may either be a path, a byte array, or a stream.
|
|
Note that if a byte array or a stream is given, a filename
|
|
or its type won't be inferred, and it will be sent as an
|
|
"unnamed application/octet-stream".
|
|
|
|
An optional caption can also be specified for said file.
|
|
|
|
If "force_document" is False, the file will be sent as a photo
|
|
if it's recognised to have a common image format (e.g. .png, .jpg).
|
|
|
|
Otherwise, the file will always be sent as an uncompressed document.
|
|
|
|
Subsequent calls with the very same file will result in
|
|
immediate uploads, unless .clear_file_cache() is called.
|
|
|
|
If "progress_callback" is not None, it should be a function that
|
|
takes two parameters, (bytes_uploaded, total_bytes).
|
|
|
|
The "reply_to" parameter works exactly as the one on .send_message.
|
|
|
|
If "attributes" is set to be a list of DocumentAttribute's, these
|
|
will override the automatically inferred ones (so that you can
|
|
modify the file name of the file sent for instance).
|
|
|
|
If "is_voice_note" in kwargs, despite its value, and the file is
|
|
sent as a document, it will be sent as a voice note.
|
|
|
|
The entity may be a phone or an username at the expense of
|
|
some performance loss.
|
|
"""
|
|
as_photo = False
|
|
if isinstance(file, str):
|
|
lowercase_file = file.lower()
|
|
as_photo = any(
|
|
lowercase_file.endswith(ext)
|
|
for ext in ('.png', '.jpg', '.gif', '.jpeg')
|
|
)
|
|
|
|
file_hash = hash(file)
|
|
if file_hash in self._upload_cache:
|
|
file_handle = self._upload_cache[file_hash]
|
|
else:
|
|
self._upload_cache[file_hash] = file_handle = self.upload_file(
|
|
file, progress_callback=progress_callback
|
|
)
|
|
|
|
if as_photo and not force_document:
|
|
media = InputMediaUploadedPhoto(file_handle, caption)
|
|
else:
|
|
mime_type = None
|
|
if isinstance(file, str):
|
|
# Determine mime-type and attributes
|
|
# Take the first element by using [0] since it returns a tuple
|
|
mime_type = guess_type(file)[0]
|
|
attr_dict = {
|
|
DocumentAttributeFilename:
|
|
DocumentAttributeFilename(os.path.basename(file))
|
|
# TODO If the input file is an audio, find out:
|
|
# Performer and song title and add DocumentAttributeAudio
|
|
}
|
|
else:
|
|
attr_dict = {
|
|
DocumentAttributeFilename:
|
|
DocumentAttributeFilename('unnamed')
|
|
}
|
|
|
|
if 'is_voice_note' in kwargs:
|
|
attr_dict[DocumentAttributeAudio] = \
|
|
DocumentAttributeAudio(0, voice=True)
|
|
|
|
# Now override the attributes if any. As we have a dict of
|
|
# {cls: instance}, we can override any class with the list
|
|
# of attributes provided by the user easily.
|
|
if attributes:
|
|
for a in attributes:
|
|
attr_dict[type(a)] = a
|
|
|
|
# Ensure we have a mime type, any; but it cannot be None
|
|
# 'The "octet-stream" subtype is used to indicate that a body
|
|
# contains arbitrary binary data.'
|
|
if not mime_type:
|
|
mime_type = 'application/octet-stream'
|
|
|
|
media = InputMediaUploadedDocument(
|
|
file=file_handle,
|
|
mime_type=mime_type,
|
|
attributes=list(attr_dict.values()),
|
|
caption=caption
|
|
)
|
|
|
|
# Once the media type is properly specified and the file uploaded,
|
|
# send the media message to the desired entity.
|
|
self(SendMediaRequest(
|
|
peer=self.get_input_entity(entity),
|
|
media=media,
|
|
reply_to_msg_id=self._get_reply_to(reply_to)
|
|
))
|
|
|
|
def send_voice_note(self, entity, file, caption='', upload_progress=None,
|
|
reply_to=None):
|
|
"""Wrapper method around .send_file() with is_voice_note=()"""
|
|
return self.send_file(entity, file, caption,
|
|
upload_progress=upload_progress,
|
|
reply_to=reply_to,
|
|
is_voice_note=()) # empty tuple is enough
|
|
|
|
def clear_file_cache(self):
|
|
"""Calls to .send_file() will cache the remote location of the
|
|
uploaded files so that subsequent files can be immediate, so
|
|
uploading the same file path will result in using the cached
|
|
version. To avoid this a call to this method should be made.
|
|
"""
|
|
self._upload_cache.clear()
|
|
|
|
# endregion
|
|
|
|
# region Downloading media requests
|
|
|
|
def download_profile_photo(self, entity, file=None, download_big=True):
|
|
"""Downloads the profile photo for an user or a chat (channels too).
|
|
Returns None if no photo was provided, or if it was Empty.
|
|
|
|
If an entity itself (an user, chat or channel) is given, the photo
|
|
to be downloaded will be downloaded automatically.
|
|
|
|
On success, the file path is returned since it may differ from
|
|
the one provided.
|
|
|
|
The specified output file can either be a file path, a directory,
|
|
or a stream-like object. If the path exists and is a file, it will
|
|
be overwritten.
|
|
|
|
The entity may be a phone or an username at the expense of
|
|
some performance loss.
|
|
"""
|
|
possible_names = []
|
|
if not isinstance(entity, TLObject) or type(entity).SUBCLASS_OF_ID in (
|
|
0x2da17977, 0xc5af5d94, 0x1f4661b9, 0xd49a2697
|
|
):
|
|
# Maybe it is an user or a chat? Or their full versions?
|
|
#
|
|
# The hexadecimal numbers above are simply:
|
|
# hex(crc32(x.encode('ascii'))) for x in
|
|
# ('User', 'Chat', 'UserFull', 'ChatFull')
|
|
entity = self.get_entity(entity)
|
|
if not hasattr(entity, 'photo'):
|
|
# Special case: may be a ChatFull with photo:Photo
|
|
# This is different from a normal UserProfilePhoto and Chat
|
|
if hasattr(entity, 'chat_photo'):
|
|
return self._download_photo(
|
|
entity.chat_photo, file,
|
|
date=None, progress_callback=None
|
|
)
|
|
else:
|
|
# Give up
|
|
return None
|
|
|
|
for attr in ('username', 'first_name', 'title'):
|
|
possible_names.append(getattr(entity, attr, None))
|
|
|
|
entity = entity.photo
|
|
|
|
if not isinstance(entity, UserProfilePhoto) and \
|
|
not isinstance(entity, ChatPhoto):
|
|
return None
|
|
|
|
if download_big:
|
|
photo_location = entity.photo_big
|
|
else:
|
|
photo_location = entity.photo_small
|
|
|
|
file = self._get_proper_filename(
|
|
file, 'profile_photo', '.jpg',
|
|
possible_names=possible_names
|
|
)
|
|
|
|
# Download the media with the largest size input file location
|
|
self.download_file(
|
|
InputFileLocation(
|
|
volume_id=photo_location.volume_id,
|
|
local_id=photo_location.local_id,
|
|
secret=photo_location.secret
|
|
),
|
|
file
|
|
)
|
|
return file
|
|
|
|
def download_media(self, message, file=None, progress_callback=None):
|
|
"""Downloads the media from a specified Message (it can also be
|
|
the message.media) into the desired file (a stream or str),
|
|
optionally finding its extension automatically.
|
|
|
|
The specified output file can either be a file path, a directory,
|
|
or a stream-like object. If the path exists and is a file, it will
|
|
be overwritten.
|
|
|
|
If the operation succeeds, the path will be returned (since
|
|
the extension may have been added automatically). Otherwise,
|
|
None is returned.
|
|
|
|
The progress_callback should be a callback function which takes
|
|
two parameters, uploaded size and total file size (both in bytes).
|
|
This will be called every time a part is downloaded
|
|
"""
|
|
# TODO This won't work for messageService
|
|
if isinstance(message, Message):
|
|
date = message.date
|
|
media = message.media
|
|
else:
|
|
date = datetime.now()
|
|
media = message
|
|
|
|
if isinstance(media, MessageMediaPhoto):
|
|
return self._download_photo(
|
|
media, file, date, progress_callback
|
|
)
|
|
elif isinstance(media, MessageMediaDocument):
|
|
return self._download_document(
|
|
media, file, date, progress_callback
|
|
)
|
|
elif isinstance(media, MessageMediaContact):
|
|
return self._download_contact(
|
|
media, file
|
|
)
|
|
|
|
def _download_photo(self, mm_photo, file, date, progress_callback):
|
|
"""Specialized version of .download_media() for photos"""
|
|
|
|
# Determine the photo and its largest size
|
|
photo = mm_photo.photo
|
|
largest_size = photo.sizes[-1]
|
|
file_size = largest_size.size
|
|
largest_size = largest_size.location
|
|
|
|
file = self._get_proper_filename(file, 'photo', '.jpg', date=date)
|
|
|
|
# Download the media with the largest size input file location
|
|
self.download_file(
|
|
InputFileLocation(
|
|
volume_id=largest_size.volume_id,
|
|
local_id=largest_size.local_id,
|
|
secret=largest_size.secret
|
|
),
|
|
file,
|
|
file_size=file_size,
|
|
progress_callback=progress_callback
|
|
)
|
|
return file
|
|
|
|
def _download_document(self, mm_doc, file, date, progress_callback):
|
|
"""Specialized version of .download_media() for documents"""
|
|
document = mm_doc.document
|
|
file_size = document.size
|
|
|
|
possible_names = []
|
|
for attr in document.attributes:
|
|
if isinstance(attr, DocumentAttributeFilename):
|
|
possible_names.insert(0, attr.file_name)
|
|
|
|
elif isinstance(attr, DocumentAttributeAudio):
|
|
possible_names.append('{} - {}'.format(
|
|
attr.performer, attr.title
|
|
))
|
|
|
|
file = self._get_proper_filename(
|
|
file, 'document', utils.get_extension(mm_doc),
|
|
date=date, possible_names=possible_names
|
|
)
|
|
|
|
self.download_file(
|
|
InputDocumentFileLocation(
|
|
id=document.id,
|
|
access_hash=document.access_hash,
|
|
version=document.version
|
|
),
|
|
file,
|
|
file_size=file_size,
|
|
progress_callback=progress_callback
|
|
)
|
|
return file
|
|
|
|
@staticmethod
|
|
def _download_contact(mm_contact, file):
|
|
"""Specialized version of .download_media() for contacts.
|
|
Will make use of the vCard 4.0 format
|
|
"""
|
|
first_name = mm_contact.first_name
|
|
last_name = mm_contact.last_name
|
|
phone_number = mm_contact.phone_number
|
|
|
|
if isinstance(file, str):
|
|
file = TelegramClient._get_proper_filename(
|
|
file, 'contact', '.vcard',
|
|
possible_names=[first_name, phone_number, last_name]
|
|
)
|
|
f = open(file, 'w', encoding='utf-8')
|
|
else:
|
|
f = file
|
|
|
|
try:
|
|
f.write('BEGIN:VCARD\n')
|
|
f.write('VERSION:4.0\n')
|
|
f.write('N:{};{};;;\n'.format(
|
|
first_name, last_name if last_name else '')
|
|
)
|
|
f.write('FN:{}\n'.format(' '.join((first_name, last_name))))
|
|
f.write('TEL;TYPE=cell;VALUE=uri:tel:+{}\n'.format(
|
|
phone_number))
|
|
f.write('END:VCARD\n')
|
|
finally:
|
|
# Only close the stream if we opened it
|
|
if isinstance(file, str):
|
|
f.close()
|
|
|
|
return file
|
|
|
|
@staticmethod
|
|
def _get_proper_filename(file, kind, extension,
|
|
date=None, possible_names=None):
|
|
"""Gets a proper filename for 'file', if this is a path.
|
|
|
|
'kind' should be the kind of the output file (photo, document...)
|
|
'extension' should be the extension to be added to the file if
|
|
the filename doesn't have any yet
|
|
'date' should be when this file was originally sent, if known
|
|
'possible_names' should be an ordered list of possible names
|
|
|
|
If no modification is made to the path, any existing file
|
|
will be overwritten.
|
|
If any modification is made to the path, this method will
|
|
ensure that no existing file will be overwritten.
|
|
"""
|
|
if file is not None and not isinstance(file, str):
|
|
# Probably a stream-like object, we cannot set a filename here
|
|
return file
|
|
|
|
if file is None:
|
|
file = ''
|
|
elif os.path.isfile(file):
|
|
# Make no modifications to valid existing paths
|
|
return file
|
|
|
|
if os.path.isdir(file) or not file:
|
|
try:
|
|
name = None if possible_names is None else next(
|
|
x for x in possible_names if x
|
|
)
|
|
except StopIteration:
|
|
name = None
|
|
|
|
if not name:
|
|
name = '{}_{}-{:02}-{:02}_{:02}-{:02}-{:02}'.format(
|
|
kind,
|
|
date.year, date.month, date.day,
|
|
date.hour, date.minute, date.second,
|
|
)
|
|
file = os.path.join(file, name)
|
|
|
|
directory, name = os.path.split(file)
|
|
name, ext = os.path.splitext(name)
|
|
if not ext:
|
|
ext = extension
|
|
|
|
result = os.path.join(directory, name + ext)
|
|
if not os.path.isfile(result):
|
|
return result
|
|
|
|
i = 1
|
|
while True:
|
|
result = os.path.join(directory, '{} ({}){}'.format(name, i, ext))
|
|
if not os.path.isfile(result):
|
|
return result
|
|
i += 1
|
|
|
|
# endregion
|
|
|
|
# endregion
|
|
|
|
# region Small utilities to make users' life easier
|
|
|
|
def get_entity(self, entity):
|
|
"""Turns an entity into a valid Telegram user or chat.
|
|
If "entity" is a string which can be converted to an integer,
|
|
or if it starts with '+' it will be resolved as if it
|
|
were a phone number.
|
|
|
|
If "entity" is a string and doesn't start with '+', or
|
|
it starts with '@', it will be resolved from the username.
|
|
If no exact match is returned, an error will be raised.
|
|
|
|
If "entity" is an integer or a "Peer", its information will
|
|
be returned through a call to self.get_input_peer(entity).
|
|
|
|
If the entity is neither, and it's not a TLObject, an
|
|
error will be raised.
|
|
"""
|
|
try:
|
|
return self.session.entities[entity]
|
|
except KeyError:
|
|
pass
|
|
|
|
if isinstance(entity, int) or (
|
|
isinstance(entity, TLObject) and
|
|
# crc32(b'InputPeer') and crc32(b'Peer')
|
|
type(entity).SUBCLASS_OF_ID in (0xc91c90b6, 0x2d45687)):
|
|
ie = self.get_input_entity(entity)
|
|
if isinstance(ie, InputPeerUser):
|
|
self(GetUsersRequest([ie]))
|
|
elif isinstance(ie, InputPeerChat):
|
|
self(GetChatsRequest([ie.chat_id]))
|
|
elif isinstance(ie, InputPeerChannel):
|
|
self(GetChannelsRequest([ie]))
|
|
try:
|
|
# session.process_entities has been called in the MtProtoSender
|
|
# with the result of these calls, so they should now be on the
|
|
# entities database.
|
|
return self.session.entities[ie]
|
|
except KeyError:
|
|
pass
|
|
|
|
if isinstance(entity, str):
|
|
return self._get_entity_from_string(entity)
|
|
|
|
raise ValueError(
|
|
'Cannot turn "{}" into any entity (user or chat)'.format(entity)
|
|
)
|
|
|
|
def _get_entity_from_string(self, string):
|
|
"""Gets an entity from the given string, which may be a phone or
|
|
an username, and processes all the found entities on the session.
|
|
"""
|
|
phone = EntityDatabase.parse_phone(string)
|
|
if phone:
|
|
entity = phone
|
|
self(GetContactsRequest(0))
|
|
else:
|
|
entity = string.strip('@').lower()
|
|
self(ResolveUsernameRequest(entity))
|
|
# MtProtoSender will call .process_entities on the requests made
|
|
try:
|
|
return self.session.entities[entity]
|
|
except KeyError:
|
|
raise ValueError(
|
|
'Could not find user with username {}'.format(entity)
|
|
)
|
|
|
|
def get_input_entity(self, peer):
|
|
"""Gets the input entity given its PeerUser, PeerChat, PeerChannel.
|
|
If no Peer class is used, peer is assumed to be the integer ID
|
|
of an User.
|
|
|
|
If this Peer hasn't been seen before by the library, all dialogs
|
|
will loaded, and their entities saved to the session file.
|
|
|
|
If even after it's not found, a ValueError is raised.
|
|
"""
|
|
try:
|
|
# First try to get the entity from cache, otherwise figure it out
|
|
return self.session.entities.get_input_entity(peer)
|
|
except KeyError:
|
|
pass
|
|
|
|
if isinstance(peer, str):
|
|
return utils.get_input_peer(self._get_entity_from_string(peer))
|
|
|
|
is_peer = False
|
|
if isinstance(peer, int):
|
|
peer = PeerUser(peer)
|
|
is_peer = True
|
|
|
|
elif isinstance(peer, TLObject):
|
|
is_peer = type(peer).SUBCLASS_OF_ID == 0x2d45687 # crc32(b'Peer')
|
|
if not is_peer:
|
|
try:
|
|
return utils.get_input_peer(peer)
|
|
except ValueError:
|
|
pass
|
|
|
|
if not is_peer:
|
|
raise ValueError(
|
|
'Cannot turn "{}" into an input entity.'.format(peer)
|
|
)
|
|
|
|
if self.session.save_entities:
|
|
# Not found, look in the latest dialogs.
|
|
# This is useful if for instance someone just sent a message but
|
|
# the updates didn't specify who, as this person or chat should
|
|
# be in the latest dialogs.
|
|
self(GetDialogsRequest(
|
|
offset_date=None,
|
|
offset_id=0,
|
|
offset_peer=InputPeerEmpty(),
|
|
limit=0,
|
|
exclude_pinned=True
|
|
))
|
|
try:
|
|
return self.session.entities.get_input_entity(peer)
|
|
except KeyError:
|
|
pass
|
|
|
|
raise ValueError(
|
|
'Could not find the input entity corresponding to "{}".'
|
|
'Make sure you have encountered this peer before.'.format(peer)
|
|
)
|
|
|
|
# endregion
|