"""This class represents a Client, the main mean for interacting with Telegram.

INVITE_LINK_RE = re.compile(r"^(?:https?://)?(?:t\.me/joinchat/)?([\w-]+)$")

DIALOGS_AT_ONCE = 100

UPDATES_WORKERS = 2

DOWNLOAD_WORKERS = 1

def __init__(self,

session_name: str,

api_key: tuple or ApiKey = None,

proxy: dict or Proxy = None,

test_mode: bool = False,

token: str = None,

phone_number: str = None,

phone_code: str or callable = None,

password: str = None,

first_name: str = None,

last_name: str = None,

workers: int = 4):

self.session_name = session_name

self.api_key = api_key

self.proxy = proxy

self.test_mode = test_mode

self.token = token

self.phone_number = phone_number

self.password = password

self.phone_code = phone_code

self.first_name = first_name

self.last_name = last_name

self.workers = workers

self.dc_id = None

self.auth_key = None

self.user_id = None

self.rnd_id = None

self.peers_by_id = {}

self.peers_by_username = {}

self.peers_by_phone = {}

self.channels_pts = {}

self.markdown = Markdown(self.peers_by_id)

self.html = HTML(self.peers_by_id)

self.session = None

self.is_idle = None

self.updates_queue = Queue()

self.update_queue = Queue()

self.update_handler = None

self.download_queue = Queue()

self.load_session_hook = None

self.save_session_hook = None

def start(self):

"""Use this method to start the Client after creating it.

self.load_config()

if callable(self.load_session_hook):

self.load_session_hook(self)

else:

self.load_session(self.session_name)

self.session = Session(

self.dc_id,

self.test_mode,

self.proxy,

self.auth_key,

self.api_key.api_id,

client=self

)

self.session.start()

if self.user_id is None:

if self.token is None:

self.authorize_user()

else:

self.authorize_bot()

if callable(self.save_session_hook):

self.save_session_hook(self)

else:

self.save_session()

if self.token is None:

self.get_dialogs()

self.get_contacts()

else:

self.send(functions.updates.GetState())

self.rnd_id = MsgId

for i in range(self.UPDATES_WORKERS):

Thread(target=self.updates_worker, name="UpdatesWorker#{}".format(i + 1)).start()

for i in range(self.workers):

Thread(target=self.update_worker, name="UpdateWorker#{}".format(i + 1)).start()

for i in range(self.DOWNLOAD_WORKERS):

Thread(target=self.download_worker, name="DownloadWorker#{}".format(i + 1)).start()

mimetypes.init()

def stop(self):

"""Use this method to manually stop the Client.

self.session.stop()

for _ in range(self.UPDATES_WORKERS):

self.updates_queue.put(None)

for _ in range(self.workers):

self.update_queue.put(None)

for _ in range(self.DOWNLOAD_WORKERS):

self.download_queue.put(None)

def authorize_bot(self):

try:

r = self.send(

functions.auth.ImportBotAuthorization(

flags=0,

api_id=self.api_key.api_id,

api_hash=self.api_key.api_hash,

bot_auth_token=self.token

)

)

except UserMigrate as e:

self.session.stop()

self.dc_id = e.x

self.auth_key = Auth(self.dc_id, self.test_mode, self.proxy).create()

self.session = Session(

self.dc_id,

self.test_mode,

self.proxy,

self.auth_key,

self.api_key.api_id,

client=self

)

self.session.start()

self.authorize_bot()

else:

self.user_id = r.user.id

def authorize_user(self):

phone_number_invalid_raises = self.phone_number is not None

phone_code_invalid_raises = self.phone_code is not None

password_hash_invalid_raises = self.password is not None

first_name_invalid_raises = self.first_name is not None

while True:

if self.phone_number is None:

self.phone_number = input("Enter phone number: ")

while True:

confirm = input("Is \"{}\" correct? (y/n): ".format(self.phone_number))

if confirm in ("y", "1"):

break

elif confirm in ("n", "2"):

self.phone_number = input("Enter phone number: ")

self.phone_number = self.phone_number.strip("+")

try:

r = self.send(

functions.auth.SendCode(

self.phone_number,

self.api_key.api_id,

self.api_key.api_hash

)

)

except (PhoneMigrate, NetworkMigrate) as e:

self.session.stop()

self.dc_id = e.x

self.auth_key = Auth(self.dc_id, self.test_mode, self.proxy).create()

self.session = Session(

self.dc_id,

self.test_mode,

self.proxy,

self.auth_key,

self.api_key.api_id,

client=self

)

self.session.start()

r = self.send(

functions.auth.SendCode(

self.phone_number,

self.api_key.api_id,

self.api_key.api_hash

)

)

break

except (PhoneNumberInvalid, PhoneNumberBanned) as e:

if phone_number_invalid_raises:

raise

else:

print(e.MESSAGE)

self.phone_number = None

except FloodWait as e:

print(e.MESSAGE.format(x=e.x))

time.sleep(e.x)

except Exception as e:

log.error(e, exc_info=True)

else:

break

phone_registered = r.phone_registered

phone_code_hash = r.phone_code_hash

while True:

self.phone_code = (

input("Enter phone code: ") if self.phone_code is None

else self.phone_code if type(self.phone_code) is str

else self.phone_code()

)

try:

if phone_registered:

r = self.send(

functions.auth.SignIn(

self.phone_number,

phone_code_hash,

self.phone_code

)

)

else:

try:

self.send(

functions.auth.SignIn(

self.phone_number,

phone_code_hash,

self.phone_code

)

)

except PhoneNumberUnoccupied:

pass

self.first_name = self.first_name if self.first_name is not None else input("First name: ")

self.last_name = self.last_name if self.last_name is not None else input("Last name: ")

r = self.send(

functions.auth.SignUp(

self.phone_number,

phone_code_hash,

self.phone_code,

self.first_name,

self.last_name

)

)

except (PhoneCodeInvalid, PhoneCodeEmpty, PhoneCodeExpired, PhoneCodeHashEmpty) as e:

if phone_code_invalid_raises:

raise

else:

print(e.MESSAGE)

self.phone_code = None

except FirstnameInvalid as e:

if first_name_invalid_raises:

raise

else:

print(e.MESSAGE)

self.first_name = None

except SessionPasswordNeeded as e:

print(e.MESSAGE)

r = self.send(functions.account.GetPassword())

while True:

try:

if self.password is None:

print("Hint: {}".format(r.hint))

self.password = input("Enter password: ") # TODO: Use getpass

if type(self.password) is str:

self.password = r.current_salt + self.password.encode() + r.current_salt

password_hash = sha256(self.password).digest()

r = self.send(functions.auth.CheckPassword(password_hash))

except PasswordHashInvalid as e:

if password_hash_invalid_raises:

raise

else:

print(e.MESSAGE)

self.password = None

except FloodWait as e:

print(e.MESSAGE.format(x=e.x))

time.sleep(e.x)

except Exception as e:

log.error(e, exc_info=True)

else:

break

break

except FloodWait as e:

print(e.MESSAGE.format(x=e.x))

time.sleep(e.x)

except Exception as e:

log.error(e, exc_info=True)

else:

break

self.password = None

self.user_id = r.user.id

def fetch_peers(self, entities: list):

for entity in entities:

if isinstance(entity, User):

user_id = entity.id

if user_id in self.peers_by_id:

continue

access_hash = entity.access_hash

if access_hash is None:

continue

username = entity.username

phone = entity.phone

input_peer = InputPeerUser(

user_id=user_id,

access_hash=access_hash

)

self.peers_by_id[user_id] = input_peer

if username is not None:

self.peers_by_username[username] = input_peer

if phone is not None:

self.peers_by_phone[phone] = input_peer

if isinstance(entity, Chat):

chat_id = entity.id

peer_id = -chat_id

if peer_id in self.peers_by_id:

continue

input_peer = InputPeerChat(

chat_id=chat_id

)

self.peers_by_id[peer_id] = input_peer

if isinstance(entity, Channel):

channel_id = entity.id

peer_id = int("-100" + str(channel_id))

if peer_id in self.peers_by_id:

continue

access_hash = entity.access_hash

if access_hash is None:

continue

username = entity.username

input_peer = InputPeerChannel(

channel_id=channel_id,

access_hash=access_hash

)

self.peers_by_id[peer_id] = input_peer

if username is not None:

self.peers_by_username[username] = input_peer

def download_worker(self):

name = threading.current_thread().name

log.debug("{} started".format(name))

while True:

media = self.download_queue.get()

if media is None:

break

try:

media, file_name, done, progress, path = media

tmp_file_name = None

if isinstance(media, types.MessageMediaDocument):

document = media.document

if isinstance(document, types.Document):

if not file_name:

file_name = "doc_{}{}".format(

datetime.fromtimestamp(document.date).strftime("%Y-%m-%d_%H-%M-%S"),

".txt" if document.mime_type == "text/plain" else

mimetypes.guess_extension(document.mime_type) if document.mime_type else ".unknown"

)

for i in document.attributes:

if isinstance(i, types.DocumentAttributeFilename):

file_name = i.file_name

break

elif isinstance(i, types.DocumentAttributeSticker):

file_name = file_name.replace("doc", "sticker")

elif isinstance(i, types.DocumentAttributeAudio):

file_name = file_name.replace("doc", "audio")

elif isinstance(i, types.DocumentAttributeVideo):

file_name = file_name.replace("doc", "video")

elif isinstance(i, types.DocumentAttributeAnimated):

file_name = file_name.replace("doc", "gif")

tmp_file_name = self.get_file(

dc_id=document.dc_id,

id=document.id,

access_hash=document.access_hash,

version=document.version,

size=document.size,

progress=progress

)

elif isinstance(media, (types.MessageMediaPhoto, types.Photo)):

if isinstance(media, types.MessageMediaPhoto):

photo = media.photo

else:

photo = media

if isinstance(photo, types.Photo):

if not file_name:

file_name = "photo_{}_{}.jpg".format(

datetime.fromtimestamp(photo.date).strftime("%Y-%m-%d_%H-%M-%S"),

self.rnd_id()

)

photo_loc = photo.sizes[-1].location

tmp_file_name = self.get_file(

dc_id=photo_loc.dc_id,

volume_id=photo_loc.volume_id,

local_id=photo_loc.local_id,

secret=photo_loc.secret,

size=photo.sizes[-1].size,

progress=progress

)

if file_name is not None:

path[0] = "downloads/{}".format(file_name)

try:

os.remove("downloads/{}".format(file_name))

except OSError:

pass

finally:

try:

os.renames("{}".format(tmp_file_name), "downloads/{}".format(file_name))

except OSError:

pass

except Exception as e:

log.error(e, exc_info=True)

finally:

done.set()

try:

os.remove("{}".format(tmp_file_name))

except OSError:

pass

log.debug("{} stopped".format(name))

def updates_worker(self):

name = threading.current_thread().name

log.debug("{} started".format(name))

while True:

updates = self.updates_queue.get()

if updates is None:

break

try:

if isinstance(updates, (types.Update, types.UpdatesCombined)):

self.fetch_peers(updates.users)

self.fetch_peers(updates.chats)

for update in updates.updates:

channel_id = getattr(

getattr(

getattr(

update, "message", None

), "to_id", None

), "channel_id", None

) or getattr(update, "channel_id", None)

pts = getattr(update, "pts", None)

if channel_id and pts:

if channel_id not in self.channels_pts:

self.channels_pts[channel_id] = []

if pts in self.channels_pts[channel_id]:

continue

self.channels_pts[channel_id].append(pts)

if len(self.channels_pts[channel_id]) > 50:

self.channels_pts[channel_id] = self.channels_pts[channel_id][25:]

self.update_queue.put((update, updates.users, updates.chats))

elif isinstance(updates, (types.UpdateShortMessage, types.UpdateShortChatMessage)):

diff = self.send(

functions.updates.GetDifference(

pts=updates.pts - updates.pts_count,

date=updates.date,

qts=-1

)

)

self.fetch_peers(diff.users)

self.fetch_peers(diff.chats)

self.update_queue.put((

types.UpdateNewMessage(

message=diff.new_messages[0],

pts=updates.pts,

pts_count=updates.pts_count

),

diff.users,

diff.chats

))

elif isinstance(updates, types.UpdateShort):

self.update_queue.put((updates.update, [], []))

except Exception as e:

log.error(e, exc_info=True)

log.debug("{} stopped".format(name))

def update_worker(self):

name = threading.current_thread().name

log.debug("{} started".format(name))

while True:

update = self.update_queue.get()

if update is None:

break

try:

if self.update_handler:

self.update_handler(

self,

update[0],

{i.id: i for i in update[1]},

{i.id: i for i in update[2]}

)

except Exception as e:

log.error(e, exc_info=True)

log.debug("{} stopped".format(name))

def signal_handler(self, *args):

self.stop()

self.is_idle = False

def idle(self, stop_signals: tuple = (SIGINT, SIGTERM, SIGABRT)):

"""Blocks the program execution until one of the signals are received,

for s in stop_signals:

signal(s, self.signal_handler)

self.is_idle = True

while self.is_idle:

time.sleep(1)

def set_update_handler(self, callback: callable):

"""Use this method to set the update handler.

self.update_handler = callback

def send(self, data: Object):

"""Use this method to send Raw Function queries.

r = self.session.send(data)

self.fetch_peers(getattr(r, "users", []))

self.fetch_peers(getattr(r, "chats", []))

return r

def load_config(self):

parser = ConfigParser()

parser.read("config.ini")

if parser.has_section("pyrogram"):

self.api_key = ApiKey(

api_id=parser.getint("pyrogram", "api_id"),

api_hash=parser.get("pyrogram", "api_hash")

)

else:

self.api_key = ApiKey(

api_id=int(self.api_key[0]),

api_hash=self.api_key[1]

)

if parser.has_section("proxy"):

self.proxy = Proxy(

enabled=parser.getboolean("proxy", "enabled"),

hostname=parser.get("proxy", "hostname"),

port=parser.getint("proxy", "port"),

username=parser.get("proxy", "username", fallback=None) or None,

password=parser.get("proxy", "password", fallback=None) or None

)

else:

if self.proxy is not None:

self.proxy = Proxy(

enabled=True,

hostname=self.proxy["hostname"],

port=int(self.proxy["port"]),

username=self.proxy.get("username", None),

password=self.proxy.get("password", None)

)

def load_session(self, session_name):

try:

with open("{}.session".format(session_name), encoding="utf-8") as f:

s = json.load(f)

except FileNotFoundError:

self.dc_id = 1

self.auth_key = Auth(self.dc_id, self.test_mode, self.proxy).create()

else:

self.dc_id = s["dc_id"]

self.test_mode = s["test_mode"]

self.auth_key = base64.b64decode("".join(s["auth_key"]))

self.user_id = s["user_id"]

def save_session(self):

auth_key = base64.b64encode(self.auth_key).decode()

auth_key = [auth_key[i: i + 43] for i in range(0, len(auth_key), 43)]

with open("{}.session".format(self.session_name), "w", encoding="utf-8") as f:

json.dump(

dict(

dc_id=self.dc_id,

test_mode=self.test_mode,

auth_key=auth_key,

user_id=self.user_id,

),

f,

indent=4

)

def get_dialogs(self):

def parse_dialogs(d):

for m in reversed(d.messages):

if isinstance(m, types.MessageEmpty):

continue

else:

return m.date

else:

return 0

pinned_dialogs = self.send(functions.messages.GetPinnedDialogs())

parse_dialogs(pinned_dialogs)

dialogs = self.send(

functions.messages.GetDialogs(

0, 0, InputPeerEmpty(),

self.DIALOGS_AT_ONCE, True

)

)

offset_date = parse_dialogs(dialogs)

log.info("Entities count: {}".format(len(self.peers_by_id)))

while len(dialogs.dialogs) == self.DIALOGS_AT_ONCE:

try:

dialogs = self.send(

functions.messages.GetDialogs(

offset_date, 0, types.InputPeerEmpty(),

self.DIALOGS_AT_ONCE, True

)

)

except FloodWait as e:

log.warning("get_dialogs flood: waiting {} seconds".format(e.x))

time.sleep(e.x)

continue

offset_date = parse_dialogs(dialogs)

log.info("Entities count: {}".format(len(self.peers_by_id)))

def resolve_username(self, username: str):

username = username.lower().strip("@")

resolved_peer = self.send(

functions.contacts.ResolveUsername(

username=username

)

) # type: types.contacts.ResolvedPeer

if type(resolved_peer.peer) is PeerUser:

input_peer = InputPeerUser(

user_id=resolved_peer.users[0].id,

access_hash=resolved_peer.users[0].access_hash

)

peer_id = input_peer.user_id

elif type(resolved_peer.peer) is PeerChannel:

input_peer = InputPeerChannel(

channel_id=resolved_peer.chats[0].id,

access_hash=resolved_peer.chats[0].access_hash

)

peer_id = int("-100" + str(input_peer.channel_id))

else:

raise PeerIdInvalid

self.peers_by_username[username] = input_peer

self.peers_by_id[peer_id] = input_peer

return input_peer

def resolve_peer(self, peer_id: int or str):

"""Use this method to get the *InputPeer* of a known *peer_id*.

if type(peer_id) is str:

if peer_id in ("self", "me"):

return InputPeerSelf()

match = self.INVITE_LINK_RE.match(peer_id)

try:

decoded = base64.b64decode(match.group(1) + "=" * (-len(match.group(1)) % 4), "-_")

return self.resolve_peer(struct.unpack(">2iq", decoded)[1])

except (AttributeError, binascii.Error, struct.error):

pass

peer_id = peer_id.lower().strip("@+")

try:

int(peer_id)

except ValueError:

try:

return self.peers_by_username[peer_id]

except KeyError:

return self.resolve_username(peer_id)

else:

try:

return self.peers_by_phone[peer_id]

except KeyError:

raise PeerIdInvalid

if type(peer_id) is not int:

if isinstance(peer_id, types.PeerUser):

peer_id = peer_id.user_id

elif isinstance(peer_id, types.PeerChat):

peer_id = -peer_id.chat_id

elif isinstance(peer_id, types.PeerChannel):

peer_id = int("-100" + str(peer_id.channel_id))

try: # User

return self.peers_by_id[peer_id]

except KeyError:

try: # Chat

return self.peers_by_id[-peer_id]

except KeyError:

try: # Channel

return self.peers_by_id[int("-100" + str(peer_id))]

except (KeyError, ValueError):

raise PeerIdInvalid

def get_me(self):

"""A simple method for testing the user authorization. Requires no parameters.

return self.send(

functions.users.GetFullUser(

InputPeerSelf()

)

)

def send_message(self,

chat_id: int or str,

text: str,

parse_mode: str = "",

disable_web_page_preview: bool = None,

disable_notification: bool = None,

reply_to_message_id: int = None):

"""Use this method to send text messages.