def main(args) -> None:
if args.api_id > 0 and args.api_hash != '' and args.phone > 0:
client = TelegramClient('chatwipe', args.api_id, args.api_hash)
client.start(str('+') + str(args.phone))
peer = choose_peer(client, args.peer)
messages_found = get_messages(
client, peer.id, peer.access_hash, args.until,
client.get_me().username or client.get_me().first_name)
if args.mode == 'delete' and len(messages_found) > 0:
print("[WARN] Going to delete among {} messages".format(
len(messages_found)))
for chunk in message_chunks(messages_found, 100):
if args.mode == 'delete':
affected_messages = client.delete_messages(
InputPeerChannel(peer.id, peer.access_hash), chunk)
print("[INFO] Deleted {} messages".format(
affected_messages[0].pts_count))
elif args.mode == 'list':
for post in chunk:
print("[INFO] ({}) [ID:{}]: {}".format(
str(post.date.strftime("%b %d %Y %H:%M:%S UTC")),
str(post.id), str(post.message)))
else:
print('[ERROR] Please provide the necessary values for the params')
def main(args) -> None:
if args.api_id > 0 and args.api_hash != '' and args.phone > 0:
client = TelegramClient('chatwipe', args.api_id, args.api_hash)
client.start(str('+') + str(args.phone))
peers = choose_peer(client, args.peer)
for peer in peers:
print(f'[INFO] Peer: {peer.title}')
messages_found = get_messages(client, peer.id, peer.access_hash,
args.until)
if args.mode == 'delete' and len(messages_found) > 0:
print(
f'[WARN] Going to delete among {len(messages_found)} messages'
)
for chunk in message_chunks(messages_found, 100):
if args.mode == 'delete':
affected_messages = client.delete_messages(
InputPeerChannel(peer.id, peer.access_hash), chunk)
print(
f'[INFO] Deleted {affected_messages[0].pts_count} messages'
)
elif args.mode == 'list':
for post in chunk:
print(
f'[INFO] ({str(post.date.strftime("%b %d %Y %H:%M:%S UTC"))}) [ID:{str(post.id)}]: {post.message}'
)
else:
print('[ERROR] Please provide the necessary values for the params')
class IntegrationTestBase(object):
def __init__(self):
api_id = 34057
api_hash = 'a89154bb0cde970cae0848dc7f7a6108'
phone = '+491728656978'
self.client = TelegramClient('josxa',
api_id,
api_hash,
update_workers=4)
self.client.start(phone)
self._live_mode = False
self._last_response = None
self._responses = {}
self.client.add_event_handler(
self.event_handler,
events.NewMessage(chats=('@InsuranceBaBot', '@josxasandboxbot'),
incoming=True))
def set_draft(self, markdown_text, reply_to=None):
text, entities = self.client._parse_message_text(
markdown_text, 'markdown')
return self.client(
SaveDraftRequest(peer=self._peer,
message=text,
no_webpage=True,
reply_to_msg_id=reply_to,
entities=entities))
@property
def live_mode(self):
return self._live_mode
@live_mode.setter
def live_mode(self, value):
self._live_mode = value
self._peer = self.client.get_input_entity(
"@InsuranceBABot" if self._live_mode else "@josxasandboxbot")
def disconnect(self):
self.client.disconnect()
def event_handler(self, event):
self._last_response = Response.from_event(event)
def delete_history(self, max_id=None, full=False):
if full:
self.client(DeleteHistoryRequest(self._peer, max_id or 2147483647))
else:
for m in paginate(
self.client.iter_messages(self._peer, limit=10000), 100):
self.client.delete_messages(self._peer, m)
def send_message_get_response(self,
text,
timeout=20,
raise_=True,
min_wait_consecutive=None,
**kwargs) -> Response:
"""
Sends a message to the bot and waits for the response.
:param text: Message to send
:param timeout: Timout in seconds
:return:
"""
if min_wait_consecutive is None:
min_wait_consecutive = ChatAction.Delay.VERY_LONG.value + (
0.3 if self.live_mode else 0.8)
return self._act_await_response(
lambda: self.client.send_message(self._peer, text, **kwargs),
NewMessage(incoming=True, chats=[self._peer]),
timeout=timeout,
raise_=raise_,
min_wait_consecutive=min_wait_consecutive)
def _act_await_response(self,
action: Callable,
event_builder: NewMessage,
timeout=20,
raise_=True,
min_wait_consecutive=5):
id_ = uuid4()
self._responses[id_] = None
def await_(event):
self._responses[id_] = Response.from_event(event)
handler = self.client.add_event_handler(await_, event_builder)
if action:
action()
# Wait `timeout` seconds for a response
end = datetime.now() + timedelta(seconds=timeout)
while self._responses[id_] is None:
if datetime.now() > end:
if raise_:
raise NoResponseReceived()
return
time.sleep(0.3)
# response received - wait a bit to see if the bot keeps sending messages
if settings.NO_DELAYS:
sleep_time = 0.8
else:
sleep_time = min_wait_consecutive
last_response = self._responses[id_]
time.sleep(sleep_time)
while self._responses[id_] != last_response:
last_response = self._responses[id_]
time.sleep(sleep_time)
self.client.remove_event_handler(handler)
result = self._responses.pop(id_)
time.sleep(0.15)
return result
def wait_outgoing(self, text):
no_markdown, _ = self.client._parse_message_text(text, 'markdown')
result = self._act_await_response(lambda: self._act_await_response(
None,
NewMessage(outgoing=True, pattern=re.escape(no_markdown)),
min_wait_consecutive=0,
timeout=99999),
NewMessage(incoming=True,
chats=[self._peer]),
min_wait_consecutive=3)
return result
class TelegramApi:
client = None
dialogs = []
messages = []
need_update_message = 0
need_update_online = 0
need_update_current_user = -1
need_update_read_messages = 0
def __init__(self):
config = configparser.ConfigParser()
config.read('config.ini')
api_id = config.get('telegram_api', 'api_id')
api_hash = config.get('telegram_api', 'api_hash')
workers = config.get('telegram_api', 'workers')
session_name = config.get('telegram_api', 'session_name')
self.timezone = int(config.get('other', 'timezone'))
self.message_dialog_len = int(config.get('app', 'message_dialog_len'))
# proxy settings
if config.get('proxy', 'type') == "HTTP":
proxy_type = socks.HTTP
elif config.get('proxy', 'type') == "SOCKS4":
proxy_type = socks.SOCKS4
elif config.get('proxy', 'type') == "SOCKS5":
proxy_type = socks.SOCKS5
else:
proxy_type = None
proxy_addr = config.get('proxy', 'addr')
proxy_port = int(config.get('proxy', 'port')) if config.get('proxy', 'port').isdigit() else None
proxy_username = config.get('proxy', 'username')
proxy_password = config.get('proxy', 'password')
proxy = (proxy_type, proxy_addr, proxy_port, False, proxy_username, proxy_password)
# create connection
self.client = TelegramClient(session_name, api_id, api_hash, update_workers=int(workers),
spawn_read_thread=True, proxy=proxy)
self.client.start()
self.me = self.client.get_me()
self.dialogs = self.client.get_dialogs(limit=self.message_dialog_len)
self.messages = len(self.dialogs) * [None]
self.online = len(self.dialogs) * [""]
self.messages[0] = self.client.get_message_history(self.dialogs[0].entity, limit=self.message_dialog_len)
# event for new messages
@self.client.on(events.NewMessage)
def my_event_handler(event):
for i in range(len(self.dialogs)):
# if event message from user
if hasattr(self.dialogs[i].dialog.peer, 'user_id') and hasattr(event._chat_peer, 'user_id') and \
self.dialogs[i].dialog.peer.user_id == event._chat_peer.user_id:
self.event_message(i)
# from chat
elif hasattr(self.dialogs[i].dialog.peer, 'chat_id') and hasattr(event._chat_peer, 'chat_id') and \
self.dialogs[i].dialog.peer.chat_id == event._chat_peer.chat_id:
self.event_message(i)
# from chat
elif hasattr(self.dialogs[i].dialog.peer, 'channel_id') and hasattr(event._chat_peer, 'channel_id') and \
self.dialogs[i].dialog.peer.channel_id == event._chat_peer.channel_id:
self.event_message(i)
# other
else:
pass
# event for read messages
@self.client.on(events.Raw())
def my_event_handler(event):
if hasattr(event, 'confirm_received') and hasattr(event, 'max_id'):
for i in range(len(self.dialogs)):
# from user
if hasattr(self.dialogs[i].dialog.peer, 'user_id') and hasattr(event.peer, 'user_id') and \
self.dialogs[i].dialog.peer.user_id == event.peer.user_id:
self.dialogs[i].dialog.read_outbox_max_id = event.max_id
self.need_update_current_user = i
# from chat
elif hasattr(self.dialogs[i].dialog.peer, 'chat_id') and hasattr(event.peer, 'chat_id') and \
self.dialogs[i].dialog.peer.chat_id == event.peer.chat_id:
self.dialogs[i].dialog.read_outbox_max_id = event.max_id
self.need_update_current_user = i
# other
else:
pass
self.need_update_read_messages = 1
# event for online/offline
@self.client.on(events.UserUpdate(chats=None, blacklist_chats=False))
def my_event_handler(event):
for i in range(len(self.dialogs)):
if hasattr(self.dialogs[i].dialog.peer, 'user_id') and hasattr(event._chat_peer, 'user_id') and \
self.dialogs[i].dialog.peer.user_id == event._chat_peer.user_id:
# I think need little bit change this
if event.online:
self.online[i] = "Online"
elif event.last_seen is not None:
self.online[i] = "Last seen at " + str(event.last_seen + (timedelta(self.timezone) // 24))
else:
self.online[i] = ""
self.need_update_current_user = i
self.need_update_online = 1
def event_message(self, user_id):
if self.messages[user_id] is None:
self.get_messages(user_id)
new_message = self.client.get_message_history(self.dialogs[user_id].entity,
min_id=self.messages[user_id][0].id - 1)
else:
new_message = self.client.get_message_history(self.dialogs[user_id].entity,
min_id=self.messages[user_id][0].id)
for j in range(len(new_message) - 1, -1, -1):
self.messages[user_id].insert(0, new_message[j])
self.dialogs[user_id].unread_count += 1
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
self.remove_duplicates(self.messages[user_id])
self.need_update_message = 1
self.need_update_current_user = user_id
def get_messages(self, user_id):
if self.messages[user_id] is None:
data = self.client.get_message_history(self.dialogs[user_id].entity, limit=self.message_dialog_len)
# need check exceptions
self.messages[user_id] = data
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
return data
else:
return self.messages[user_id]
def get_message_by_id(self, user_id, message_id):
for i in range(len(self.messages[user_id])):
if self.messages[user_id][i].id == message_id:
return self.messages[user_id][i]
# return self.client.get_message_history(self.dialogs[user_id].entity, limit=1, min_id=message_id-1)
def delete_message(self, user_id, message_id):
self.client.delete_messages(self.dialogs[user_id].entity, message_id)
def download_media(self, media, path):
return self.client.download_media(media, path)
def message_send(self, message, user_id, reply=None):
data = self.client.send_message(self.dialogs[user_id].entity, message, reply_to=reply)
# read message
self.client.send_read_acknowledge(self.dialogs[user_id].entity, max_id=data.id)
# save message
new_message = self.client.get_message_history(self.dialogs[user_id].entity, min_id=(data.id - 1))
for j in range(len(new_message) - 1, -1, -1):
self.messages[user_id].insert(0, new_message[j])
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
self.remove_duplicates(self.messages[user_id])
def file_send(self, file, user_id, func):
data = self.client.send_file(self.dialogs[user_id].entity, file, progress_callback=func)
# save message
new_message = self.client.get_message_history(self.dialogs[user_id].entity, min_id=(data.id - 1))
for j in range(len(new_message) - 1, -1, -1):
self.messages[user_id].insert(0, new_message[j])
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
self.remove_duplicates(self.messages[user_id])
def read_all_messages(self, user_id):
if hasattr(self.messages[user_id][0], 'id'):
self.client.send_read_acknowledge(self.dialogs[user_id].entity,
max_id=self.messages[user_id][0].id)
def remove_duplicates(self, messages):
i = 0
while i < len(messages) - 1:
if messages[i].id == messages[i + 1].id:
del messages[i]
i = i - 1
i = i + 1
return messages
class TelegramApi:
client = None
dialogs = []
messages = []
need_update_message = 0
need_update_online = 0
need_update_current_user = -1
need_update_read_messages = 0
def __init__(self):
config = configparser.ConfigParser()
config.read('config.ini')
api_id = config.get('telegram_api', 'api_id')
api_hash = config.get('telegram_api', 'api_hash')
workers = config.get('telegram_api', 'workers')
session_name = config.get('telegram_api', 'session_name')
self.timezone = int(config.get('other', 'timezone'))
self.message_dialog_len = int(config.get('app', 'message_dialog_len'))
# proxy settings
if config.get('proxy', 'type') == "HTTP":
proxy_type = socks.HTTP
elif config.get('proxy', 'type') == "SOCKS4":
proxy_type = socks.SOCKS4
elif config.get('proxy', 'type') == "SOCKS5":
proxy_type = socks.SOCKS5
else:
proxy_type = None
proxy_addr = config.get('proxy', 'addr')
proxy_port = int(config.get('proxy', 'port')) if config.get('proxy', 'port').isdigit() else None
proxy_username = config.get('proxy', 'username')
proxy_password = config.get('proxy', 'password')
proxy = (proxy_type, proxy_addr, proxy_port, False, proxy_username, proxy_password)
# create connection
self.client = TelegramClient(session_name, api_id, api_hash, update_workers=int(workers),
spawn_read_thread=True, proxy=proxy)
self.client.start()
self.me = self.client.get_me()
self.dialogs = self.client.get_dialogs(limit=self.message_dialog_len)
self.messages = len(self.dialogs) * [None]
self.online = len(self.dialogs) * [""]
self.messages[0] = self.client.get_message_history(self.dialogs[0].entity, limit=self.message_dialog_len)
# event for new messages
@self.client.on(events.NewMessage)
def my_event_handler(event):
for i in range(len(self.dialogs)):
# if event message from user
if hasattr(self.dialogs[i].dialog.peer, 'user_id') and hasattr(event._chat_peer, 'user_id') and \
self.dialogs[i].dialog.peer.user_id == event._chat_peer.user_id:
self.event_message(i)
# from chat
elif hasattr(self.dialogs[i].dialog.peer, 'chat_id') and hasattr(event._chat_peer, 'chat_id') and \
self.dialogs[i].dialog.peer.chat_id == event._chat_peer.chat_id:
self.event_message(i)
# from chat
elif hasattr(self.dialogs[i].dialog.peer, 'channel_id') and hasattr(event._chat_peer, 'channel_id') and \
self.dialogs[i].dialog.peer.channel_id == event._chat_peer.channel_id:
self.event_message(i)
# other
else:
pass
# event for read messages
@self.client.on(events.Raw(types=None))
def my_event_handler(event):
if hasattr(event, 'confirm_received') and hasattr(event, 'max_id'):
for i in range(len(self.dialogs)):
# from user
if hasattr(self.dialogs[i].dialog.peer, 'user_id') and hasattr(event.peer, 'user_id') and \
self.dialogs[i].dialog.peer.user_id == event.peer.user_id:
self.dialogs[i].dialog.read_outbox_max_id = event.max_id
self.need_update_current_user = i
# from chat
elif hasattr(self.dialogs[i].dialog.peer, 'chat_id') and hasattr(event.peer, 'chat_id') and \
self.dialogs[i].dialog.peer.chat_id == event.peer.chat_id:
self.dialogs[i].dialog.read_outbox_max_id = event.max_id
self.need_update_current_user = i
# other
else:
pass
self.need_update_read_messages = 1
# event for online/offline
@self.client.on(events.UserUpdate(chats=None, blacklist_chats=False))
def my_event_handler(event):
for i in range(len(self.dialogs)):
if hasattr(self.dialogs[i].dialog.peer, 'user_id') and hasattr(event._chat_peer, 'user_id') and \
self.dialogs[i].dialog.peer.user_id == event._chat_peer.user_id:
# I think need little bit change this
if event.online:
self.online[i] = "Online"
elif event.last_seen is not None:
self.online[i] = "Last seen at " + str(event.last_seen + (timedelta(self.timezone) // 24))
else:
self.online[i] = ""
self.need_update_current_user = i
self.need_update_online = 1
def event_message(self, user_id):
if self.messages[user_id] is None:
self.get_messages(user_id)
new_message = self.client.get_message_history(self.dialogs[user_id].entity,
min_id=self.messages[user_id][0].id - 1)
else:
new_message = self.client.get_message_history(self.dialogs[user_id].entity,
min_id=self.messages[user_id][0].id)
for j in range(len(new_message) - 1, -1, -1):
self.messages[user_id].insert(0, new_message[j])
self.dialogs[user_id].unread_count += 1
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
self.remove_duplicates(self.messages[user_id])
self.need_update_message = 1
self.need_update_current_user = user_id
def get_messages(self, user_id):
if self.messages[user_id] is None:
data = self.client.get_message_history(self.dialogs[user_id].entity, limit=self.message_dialog_len)
# need check exceptions
self.messages[user_id] = data
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
return data
else:
return self.messages[user_id]
def get_message_by_id(self, user_id, message_id):
for i in range(len(self.messages[user_id])):
if self.messages[user_id][i].id == message_id:
return self.messages[user_id][i]
# return self.client.get_message_history(self.dialogs[user_id].entity, limit=1, min_id=message_id-1)
def delete_message(self, user_id, message_id):
self.client.delete_messages(self.dialogs[user_id].entity, message_id)
def download_media(self, media, path):
return self.client.download_media(media, path)
def message_send(self, message, user_id, reply=None):
data = self.client.send_message(self.dialogs[user_id].entity, message, reply_to=reply)
# read message
self.client.send_read_acknowledge(self.dialogs[user_id].entity, max_id=data.id)
# save message
new_message = self.client.get_message_history(self.dialogs[user_id].entity, min_id=(data.id - 1))
for j in range(len(new_message) - 1, -1, -1):
self.messages[user_id].insert(0, new_message[j])
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
self.remove_duplicates(self.messages[user_id])
def file_send(self, file, user_id, func):
data = self.client.send_file(self.dialogs[user_id].entity, file, progress_callback=func)
# save message
new_message = self.client.get_message_history(self.dialogs[user_id].entity, min_id=(data.id - 1))
for j in range(len(new_message) - 1, -1, -1):
self.messages[user_id].insert(0, new_message[j])
self.messages[user_id].sort(key=lambda x: x.id, reverse=True)
self.remove_duplicates(self.messages[user_id])
def read_all_messages(self, user_id):
if hasattr(self.messages[user_id][0], 'id'):
self.client.send_read_acknowledge(self.dialogs[user_id].entity,
max_id=self.messages[user_id][0].id)
def remove_duplicates(self, messages):
i = 0
while i < len(messages) - 1:
if messages[i].id == messages[i + 1].id:
del messages[i]
i = i - 1
i = i + 1
return messages
from environs import Env
from telethon import TelegramClient, events, sync
# Lendo variáveis de ambiente do arquivo .env
env = Env()
env.read_env('.env')
api_id = env('TELEGRAM_API_ID')
api_hash = env('TELEGRAM_API_HASH')
client = TelegramClient('session_name', api_id, api_hash)
client.start()
with client:
# for dialog in client.iter_dialogs(archived=False):
# if dialog.name == 'Teste bot':
# print(dialog)
# Obter mensagens um chat (arg0) originadas por um usuário específico (from_user)
messages = client.get_messages(427777832, from_user=335653242)
# Remover mensagens do chat (arg0) somente para o usuário (revoke=False)
client.delete_messages(427777832, messages, revoke=False)
client = TelegramClient('session_name', api_id, api_hash, update_workers=0)
client.start()
print(client.get_me().stringify())
while True:
try:
update = client.updates.poll()
if not update:
continue
if (isinstance(update, UpdateNewChannelMessage)
and update.message.out == False):
if (isinstance(update.message, Message)):
messaggio = update.message.message
if any(ord(char) > 127 for char in messaggio):
client.delete_messages(update.message.to_id,
[update.message.id])
if (isinstance(update.message, MessageService)):
client.delete_messages(update.message.to_id,
[update.message.id])
if (isinstance(update.message.action,
MessageActionChatAddUser)):
for boto in update.message.action.users:
if (client.get_entity(boto).bot == True):
client(
EditBannedRequest(
update.message.to_id,
boto,
banned_rights=ChannelBannedRights(
until_date=0,
view_messages=True)))
client(
class BaseTelegramClient(AioThing):
def __init__(
self,
app_id: Union[int, str],
app_hash: str,
database: dict,
bot_token: Optional[str] = None,
mtproxy: Optional[dict] = None,
flood_sleep_threshold: int = 60,
):
super().__init__()
if not app_id or not app_hash:
raise ValueError(
'Your API ID or Hash cannot be empty or None. Set up telegram.app_id and/or telegram.app_hash'
)
self._telegram_client = TelegramClient(
self._get_session(database),
app_id,
app_hash,
flood_sleep_threshold=flood_sleep_threshold,
**self._get_proxy(mtproxy=mtproxy),
)
self.bot_token = bot_token
def _get_session(self, database):
if database.get('drivername') == 'postgresql':
self.container = AlchemySessionContainer(
f"{database['drivername']}://"
f"{database['username']}:"
f"{database['password']}@"
f"{database['host']}:"
f"{database['port']}/"
f"{database['database']}",
session=False,
manage_tables=False,
)
return self.container.new_session(database['session_id'])
else:
return sessions.SQLiteSession(session_id=database['session_id'])
def _get_proxy(self, mtproxy=None):
if mtproxy and mtproxy.get('enabled', True):
proxy_config = mtproxy
return {
'connection':
connection.tcpmtproxy.
ConnectionTcpMTProxyRandomizedIntermediate,
'proxy': (proxy_config['url'], proxy_config['port'],
proxy_config['secret'])
}
return {}
@retry(retry=retry_if_exception_type(ConnectionError), wait=wait_fixed(5))
async def start(self):
await self._telegram_client.start(bot_token=self.bot_token)
async def stop(self):
return await self.disconnect()
def add_event_handler(self, *args, **kwargs):
return self._telegram_client.add_event_handler(*args, **kwargs)
def catch_up(self):
return self._telegram_client.catch_up()
def delete_messages(self, *args, **kwargs):
return self._telegram_client.delete_messages(*args, **kwargs)
def disconnect(self):
return self._telegram_client.disconnect()
@property
def disconnected(self):
return self._telegram_client.disconnected
def download_document(self, *args, **kwargs):
return self._telegram_client._download_document(
*args,
date=datetime.datetime.now(),
thumb=None,
progress_callback=None,
msg_data=None,
**kwargs,
)
def edit_message(self, *args, **kwargs):
return self._telegram_client.edit_message(*args, **kwargs)
def edit_permissions(self, *args, **kwargs):
return self._telegram_client.edit_permissions(*args, **kwargs)
def forward_messages(self, *args, **kwargs):
return self._telegram_client.forward_messages(*args, **kwargs)
def get_entity(self, *args, **kwargs):
return self._telegram_client.get_entity(*args, **kwargs)
def get_input_entity(self, *args, **kwargs):
return self._telegram_client.get_input_entity(*args, **kwargs)
def iter_admin_log(self, *args, **kwargs):
return self._telegram_client.iter_admin_log(*args, **kwargs)
def iter_messages(self, *args, **kwargs):
return self._telegram_client.iter_messages(*args, **kwargs)
def list_event_handlers(self):
return self._telegram_client.list_event_handlers()
def remove_event_handlers(self):
for handler in reversed(self.list_event_handlers()):
self._telegram_client.remove_event_handler(*handler)
def run_until_disconnected(self):
return self._telegram_client.run_until_disconnected()
def send_message(self, *args, **kwargs):
return self._telegram_client.send_message(*args, **kwargs)
def send_file(self, *args, **kwargs):
return self._telegram_client.send_file(*args, **kwargs)
def __call__(self, *args, **kwargs):
return self._telegram_client(*args, **kwargs)
duplicate_messages = []
duplicate_ids = []
for message in messages_ds_iter:
if message.message in unique_messages:
duplicate_messages.append(message.message)
duplicate_ids.append(message.id)
print("Duplicate found:", message.id, ":", message.message)
else:
unique_messages.append(message.message)
print(duplicate_ids, file=open("output_ids.txt", "w"))
def save_to_file(message):
print(str(message.encode("unicode_escape"), "utf-8"),
"\n",
file=open("output.txt", "a"))
for message in duplicate_messages:
save_to_file(message)
print(duplicate_ids)
for message in duplicate_ids:
client.delete_messages(chat_id, message)
print("Duplicate removed:", message)
print("All duplicates removed.")
#Logging in
log("Connecting to {}...".format(number))
client.connect()
log("Connected!")
status = client.is_user_authorized()
log("Authorization status: {}".format(status))
#Sending code
if status == False:
client.send_code_request(number)
code = input("Enter code: ")
client.sign_in(number, code)
#Get the last message from Telegram
telegram_message_id = client.get_messages(777000, 1)[0].id
result = client.delete_messages(777000, [telegram_message_id])[0]
if result.pts_count == 1:
log("Code message from Telegram was deleted!")
else:
log("Something went wrong while deleting Telegram code message!")
#Setup exports folder
if clear and os.path.isdir("exports"):
log("Clearing old exports...")
shutil.rmtree("exports")
username = client.get_entity("me").username
current_time = datetime.now().strftime("%Y.%m.%d %H-%M-%S")
exports_folder = os.path.join(
"exports", parse_file_name("{} ({})".format(username, number)),
current_time)
if not os.path.exists(exports_folder):
