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):