def test_cdn_download(): client = TelegramClient(None, api_id, api_hash) client.session.set_dc(0, '149.154.167.40', 80) assert client.connect() try: phone = '+999662' + str(randint(0, 9999)).zfill(4) client.send_code_request(phone) client.sign_up('22222', 'Test', 'DC') me = client.get_me() data = os.urandom(2 ** 17) client.send_file( me, data, progress_callback=lambda c, t: print('test_cdn_download:uploading {:.2%}...'.format(c/t)) ) msg = client.get_message_history(me)[1][0] out = BytesIO() client.download_media(msg, out) assert sha256(data).digest() == sha256(out.getvalue()).digest() out = BytesIO() client.download_media(msg, out) # Won't redirect assert sha256(data).digest() == sha256(out.getvalue()).digest() client.log_out() finally: client.disconnect()
class CommandlineInterface: def __init__(self, config='~/.telegram-cloner.json'): self._config = ConfigParser(config).parse() self._tg_client = TelegramClient(self._config['app']['session'], self._config['telegram']['api_id'], self._config['telegram']['api_hash']) self._tg_client.start() def recent_media(self, username, limit=10): for m in self._tg_client.iter_messages(username, limit): filename = self._tg_client.download_media(m) if filename: print('Filename:', filename)
def execute(self): api_id = 263724 api_hash = "3a8ae22a8e6981038a370c7149d51fc2" sn_path = Path.join(Path.dirname(__file__), 'session_name') client = TelegramClient(sn_path, api_id, api_hash) client.connect() username = '******' try: for message in client.get_messages(username, limit=1): if not DBWorker.get_telega_id_date(message.id): file = client.download_media(message, Config().type_paths.get('import')) FSWorker.log('From telega was downloaded: "{}"'.format(file)) DBWorker.write_telega_id(message.id) except Exception as err: FSWorker.log("Fucken bitch dead again. BIIIIITCH")
api_hash 你的api hash channel_link 要下载图片的频道链接 proxy 将localhost改成代理地址,1080改成代理端口 picture_storage_path 图片下载到的路径 ''' api_id = 80xxxxx api_hash = "3066c1322d6931a85470xxxxxx" channel_link = "https://t.me/xx" proxy =(socks.SOCKS5,"0.0.0.0",1080) #不需要代理的话删掉该行 picture_storage_path = "/" # ========================================== client = TelegramClient('my_session',api_id=api_id,api_hash=api_hash).start() photos = client.get_messages(channel_link,None,max_id=100000,min_id=0, filter=InputMessagesFilterPhotos) total = len(photos) index = 0 for photo in photos: # filename = picture_storage_path + "/" +str(photo.text)+"_"+str(photo.id) + ".jpg" #名字_id filename = picture_storage_path + "/" +str(photo.id) + ".jpg" index = index + 1 print("downloading:", index, "/", total, " : ", filename) if os.path.exists(filename)==False: client.download_media(photo, filename) print('done!') else: print('exist!') client.disconnect() print("Done.")
def run(self, conf, args, plugins): session_file = os.path.join(os.path.expanduser("~"), ".config/harpoon/telegram") client = TelegramClient(session_file, int(conf['Telegram']['id']), conf['Telegram']['hash']) # FIXME : do not connect if it's help client.connect() if not client.is_user_authorized(): client.send_code_request(conf['Telegram']['phone']) code_ok = False while not code_ok: code = input("Enter Telegram code:") try: code_ok = client.sign_in(conf['Telegram']['phone'], code) except SessionPasswordNeededError: # FIXME: getpass is not imported, that would not work password = getpass( 'Two step verification enabled. Please enter your password: '******'subcommand'): if args.subcommand == 'id': try: res = client.get_entity(args.ID) print( json.dumps(res.to_dict(), sort_keys=True, indent=4, default=json_serial)) except ValueError: print('Identifier not found') elif args.subcommand == "messages": entity = client.get_entity(args.ID) messages = client.get_messages(entity, args.limit) users = {} if args.dump: if not os.path.exists(args.dump): os.makedirs(args.dump) if args.format == "text": if len(messages) == 0: print("No messages in this channel") else: print("%i messages downloaded:" % len(messages)) for msg in messages: if isinstance(msg, telethon.tl.types.MessageService): if isinstance( msg.action, telethon.tl.types. MessageActionChatEditPhoto): print("[%s] Channel Photo Changed" % msg.date.isoformat()) elif isinstance( msg.action, telethon.tl.types. MessageActionChannelCreate): print("[%s] Channel Created" % msg.date.isoformat()) elif isinstance( msg.action, telethon.tl.types. MessageActionChatAddUser): print( "[%s] Add Users To the Chat - %s" % (msg.date.isoformat(), ", ".join( [str(a) for a in msg.action.users]))) elif isinstance( msg.action, telethon.tl.types. MessageActionChatDeleteUser): print( "[%s] Remove User from the chat - %i" % (msg.date.isoformat(), msg.action.user_id)) else: print("[%s] Message Service: %s" % (msg.date.isoformat(), msg.action.message)) else: if msg.media is None: if entity.megagroup: if msg.from_id not in users: users[msg. from_id] = client.get_entity( msg.from_id) print( "[%s][%i - @%s] %s" % (msg.date.isoformat(), msg.from_id, users[msg.from_id].username, msg.message)) else: print("[%s] %s (%i views)" % (msg.date.isoformat(), msg.message, msg.views)) else: if msg.views: print( "[%s] Media (%i views)" % (msg.date.isoformat(), msg.views)) else: print("[%s] Media" % (msg.date.isoformat())) if args.dump: if not os.path.exists( os.path.join( args.dump, str(msg.id) + '.jpg')): client.download_media( msg.media, os.path.join( args.dump, str(msg.id))) time.sleep(7) elif args.format == "json": msg = [m.to_dict() for m in messages] print( json.dumps(msg, sort_keys=True, indent=4, default=json_serial)) if args.dump: for msg in messages: if msg.media is None: if not os.path.exists( os.path.join(args.dump, str(msg.id) + '.jpg')): client.download_media( msg.media, os.path.join(args.dump, str(msg.id))) time.sleep(7) elif args.format == "csv": if entity.megagroup: # Chat w = csv.writer(sys.stdout, delimiter=';') w.writerow([ "Date", "id", "Username", "userid", "Type", "Message" ]) for m in messages: if m.from_id not in users: users[m.from_id] = client.get_entity(m.from_id) if isinstance(m, telethon.tl.types.MessageService): w.writerow([ m.date.isoformat(), m.id, users[m.from_id].username, m.from_id, m.__class__.__name__, m.action.__class__.__name__ ]) else: w.writerow([ m.date.isoformat(), m.id, users[m.from_id].username, m.from_id, m.__class__.__name__, m.message ]) else: w = csv.writer(sys.stdout, delimiter=';') w.writerow([ "Date", "id", "Type", "Information", "Media", "Views" ]) for m in messages: if isinstance(m, telethon.tl.types.MessageService): if isinstance( m.action, telethon.tl.types. MessageActionChatEditPhoto): w.writerow([ m.date.isoformat(), m.id, m.__class__.__name__, "Channel Photo Changed", "No", "" ]) elif isinstance( m.action, telethon.tl.types. MessageActionChannelCreate): w.writerow([ m.date.isoformat(), m.id, m.__class__.__name__, "Channel Created", "No", "" ]) else: w.writerow([ m.date.isoformat(), m.id, m.__class__.__name__, m.action.__class__.__name__, "No", "" ]) else: if m.media is None: # message w.writerow([ m.date.isoformat(), m.id, m.__class__.__name__, m.message, "No", m.views ]) else: w.writerow([ m.date.isoformat(), m.id, m.__class__.__name__, m.message, "Yes", m.views ]) if args.dump: if not os.path.exists( os.path.join( args.dump, str(m.id) + '.jpg')): client.download_media( m.media, os.path.join( args.dump, str(m.id))) # Sleep to avoid being banned time.sleep(7) else: print("Not implemented yet, sorry!") elif args.subcommand == "users": # List users from a group try: entity = client.get_entity(args.ID) offset = 0 limit = args.limit all_participants = [] while True: participants = client.invoke( GetParticipantsRequest( entity, ChannelParticipantsSearch(''), offset, limit, hash=0)) if not participants.users: break all_participants.extend(participants.users) offset += len(participants.users) time.sleep( 1 ) # This line seems to be optional, no guarantees! except ChatAdminRequiredError: print( "You don't have required access rights to get this list" ) else: if args.format == "text": for p in all_participants: print("[+] User: %s (%s %s)" % (p.username, p.first_name, p.last_name)) elif args.format == "json": users = [u.to_dict() for u in all_participants] print( json.dumps(users, sort_keys=True, indent=4, default=json_serial)) else: print("Not implemented yet, sorry!") else: self.parser.print_help() else: self.parser.print_help()
bot = telegram.Bot(token=API_TOKEN) print(bot.get_me()) client = TelegramClient('test_session', API_ID, API_HASH) client.connect() # If you already have a previous 'session_name.session' file, skip this. client.sign_in(phone=PHONE) me = client.sign_in(code=79076) # Put whatever code you received here. print(me.stringify()) client.send_message('sensefilter', 'Hello! Talking to you from Telethon') #client(JoinChannelRequest(channel)) total, messages, senders = client.get_message_history('attractor137') x = client.download_media(messages[0]) print(x) from telethon.tl.functions.messages import GetDialogsRequest from telethon.tl.types import InputPeerEmpty from time import sleep dialogs = [] users = [] chats = [] messages = [] last_date = None chunk_size = 200 while True: result = client(
class SonarTelegram(): def __init__(self, loop, api_id, api_hash, collection, session_name, endpoint): self.loop = loop or asyncio.get_event_loop() self.sonar = SonarClient() self.api_id = api_id self.api_hash = api_hash self.telegram = TelegramClient(session_name, self.api_id, self.api_hash, loop=self.loop) self.data = {} async def get_jsondialogs(self): dialogs_list = [] dialogs = self.telegram.iter_dialogs() async for dialog in dialogs: dialog_json = await self.create_dialog_schema(dialog) dialogs_list.append(dialog_json) return dialogs_list async def create_dialog_schema(self, dialog): return json.dumps({ "name": dialog.name, "date": dialog.date.isoformat(), "last_message": dialog.message.message, "entity_id": dialog.id, }) async def import_message(self, entity): if not (isinstance(entity.to_id, PeerChat) or isinstance(entity.to_id, PeerChannel)): user_id = entity.from_id full = await self.telegram(GetFullUserRequest(user_id)) entity.username = full.user.username entity.first_name = full.user.first_name print(entity.username, entity.first_name, entity.message) entity_json = json.dumps(entity, cls=teleJSONEncoder) id = await self.put_message(entity_json) return id async def import_entity(self, entity_id, collection_name="telegram"): ids = [] await self.ensure_collection(collection_name) await self.ensure_types() entities = self.telegram.iter_messages(entity_id) async for entity in entities: if not (isinstance(entity.to_id, PeerChat) or isinstance(entity.to_id, PeerChannel)): user_id = entity.from_id full = await self.telegram(GetFullUserRequest(user_id)) entity.username = full.user.username entity.first_name = full.user.first_name print(entity.username, entity.first_name, entity.message) entity_json = json.dumps(entity, cls=teleJSONEncoder) id = await self.put_message(entity_json) ids.append(id) async def get_info(self): return await self.sonar.info() async def ensure_collection(self, name): self.collection = await self.sonar.create_collection(name) async def ensure_types(self): types = self.collection.schema.list_types() if 'telegram.plainMessage' not in types: pp.pprint("putting telegram types") await self.load_schemata() async def load_schemata(self): with open('./schemas/telSchema_MessageMediaPhoto.json') as json_file: data = json.load(json_file) print(data) self.collection.schema.add({'telegram.photoMessage': data}) with open('./schemas/telSchema_MessageMediaVideo.json') as json_file: data = json.load(json_file) self.collection.schema.add({'telegram.videoMessage': data}) with open('./schemas/telSchema_MessageMediaAudio.json') as json_file: data = json.load(json_file) self.collection.schema.add({'telegram.audioMessage': data}) with open('./schemas/telSchema_MessageMediaPlain.json') as json_file: data = json.load(json_file) print(data) self.collection.schema.add({'telegram.plainMessage': data}) with open('./schemas/telSchema_MessageMediaDocument.json') as json_file: data = json.load(json_file) self.collection.schema.add({'telegram.documentMessage': data}) return True async def put_message(self, message): ''' TODO: Save the remaining types (for example the Schema for channels without user_id) in ../types and adjust the if-queries here ''' # TODO: get file and push it to fs msg = json.loads(message) if msg['media'] is None: schema = "telegram.plainMessage" else: if 'MessageMediaAudio' in msg['media']: media_id = msg.get('media').get('MessageMediaAudio').get('id') schema = "telegram.audioMessage" elif 'MessageMediaVideo' in msg['media']: media_id = msg.get('media').get('MessageMediaVideo').get('id') schema = "telegram.videoMessage" elif 'MessageMediaPhoto' in msg['media']: media_id = msg.get('media').get('MessageMediaPhoto').get('id') schema = "telegram.audioPhoto" elif 'MessageMediaDocument' in msg['media']: media_id = msg.get('id') schema = "telegram.documentMessage" else: print(json.dumps(msg['media'], cls=teleJSONEncoder)) return None file_bytes = self.telegram.download_media(msg, "./file") # TODO: how to handle the file bytes coroutine object? print(media_id, str(file_bytes)) id = await self.collection.put({ "schema": schema, "value": msg, "id": "telegram." + str(msg["id"]) }) print(id) return id
import socks import telethon.sync from telethon import TelegramClient from tqdm import tqdm # Go to my.telegram.org, register desktop app and copy id and hash api_id = 123456 api_hash = 'qwertyqwerty12345123456' # If you need proxy proxy_type = socks.SOCKS5 proxy_host = 'IP' proxy_port = 1111 proxy = (proxy_type, proxy_host, proxy_port) # Go to chat settings and generate invite link # NOTE: your group chat must be a supergroup, otherwise script can't get messages chat_link = 'https://t.me/joinchat/qwertyqwerty' # 'download' it's just a session name, you can write anything here client = TelegramClient('download', api_id, api_hash, proxy=proxy) client.start() messages = client.get_messages(chat_link, limit=1000) print(len(messages)) for message in tqdm(messages): client.download_media(message)
min_id=lastmessage, hash=0)) if len(messages.messages) > 0: logger.debug('New Messages: ') logger.debug(messages) for m in messages.messages: datetime = m.date.strftime('%Y-%m-%d %H:%M:%S') if m.id > lastmessage: lastmessage = m.id try: logger.info("Relaying Message {}".format(m.id)) media = m.media if media is not None: logger.info("Will download image") logger.debug(media) download_res = tclient.download_media( media, './downloads/') logger.info("Download done: {}".format(download_res)) files = {'file': (open(download_res, 'rb'))} response = requests.post(url, files=files) logger.debug(response.text) os.remove(download_res) logger.debug("File deleted") if not m.message == '': if everyone: msgText = "@everyone {}".format(m.message) else: msgText = "{}".format(m.message) msg = Webhook(url, msg=msgText) msg.post() except: logger.info('Ignoring empty message {} action: {}'.format(
"file_name", "") if file_name.endswith("epub"): print( f" - [{msg.id} / {msg.media.document.date}] {file_name} ...", end="", ) if (len( connection.execute( f"select * from Messages where msg_id = {msg.id}" ).fetchall()) > 0): print("message already in the DB") elif glob.glob("books/" + file_name): print("file already present") else: client.download_media(message=msg, file="books/") connection.execute( f'insert into Messages values ( {msg.id}, "{file_name}" );' ) connection.commit() print("\u2713") # if glob.glob(f"books/{file_name}"): # print(get_epub_info(f"books/{file_name}")) except KeyError: print("Unable to download ") print(msg.media.document) except KeyboardInterrupt: print("\n\ngot CTRL+C, stopping ... ") connection.close() sys.exit(0)
class Main: def __init__(self): print("init") version = "20" if not os.path.exists(data_dir + "/version"): print("Writing new database") open(data_dir + "/version", "w").write("0") checkversion = str(open(data_dir + "/version", "r").readlines()[0]) if not version == checkversion: print( "Database version is incompatible with new version, recreating it" ) if os.path.exists(data_dir + "/data.db"): os.remove(data_dir + "/data.db") open(data_dir + "/version", "w").write(version) ldb.connect() try: ldb.create_tables([Info]) except: print("Info table exists in ldb") try: ldb.create_tables([Dialogs]) except: print("Dialogs table exists in ldb") try: ldb.create_tables([Chats]) except: print("Chats table exists in ldb") try: ldb.create_tables([Uploads]) except: print("Uploads table exists in ldb") ldb.close() self.isConnected = False self.ChatPartner = "" self.ChatPartnerID = "" self.ChatForceReload = False self.LastChatList = "" self.LastDialogList = "" self.threadTryConnect = threading.Thread(name="Connect", target=self.Connect, args=()) self.getDialogs() self.tryConnect() def tryConnect(self): print("tryConnect") print(threading.enumerate()) if not self.threadTryConnect.isAlive(): print("starting Thread Connect") self.threadTryConnect.start() else: print("Waiting for Connection, Thread Connect is Already running") def Connect(self): print("Connect") api_id = 291651 api_hash = '0f734eda64f8fa7dea8ed9558fd447e9' self.client = TelegramClient(data_dir + "/telepygram.db", api_id, api_hash) self.phoneNumber = "" print("Connect to Telegram") try: isConnected = self.client.connect() except: isConnected = False if isConnected: pyotherside.send("onlineStatus", True) isAuthorized = self.client.is_user_authorized() print("Authorized: " + str(isAuthorized)) if not isAuthorized: pyotherside.send("changeFrame", "Phone") print("pyotherside.send(changeFrame, Phone)") return True else: pyotherside.send("onlineStatus", False) return False def SetChatPartner(self, name, id): print("SetChatPartner(name: " + str(name) + ", " + str(id) + ")") self.ChatPartner = name self.ChatPartnerID = id self.ChatForceReload = True self.getChat() def setPhoneNumber(self, phoneNumber): self.phoneNumber = phoneNumber print("setPhoneNumber(" + str(phoneNumber) + ")") self.client.send_code_request(phoneNumber) pyotherside.send("changeFrame", "Code") print("pyotherside.send(changeFrame, Code)") def setPhoneCode(self, phoneCode): print("setPhoneCode(" + str(phoneCode) + ")") self.client.sign_in(self.phoneNumber, phoneCode) pyotherside.send("changeFrame", "Dialogs") print("pyotherside.send(changeFrame, Dialogs)") self.getDialogs() def getDialogs(self): print("getDialogs function in Main.py") Dialoge = [] try: ldb.connect() except: True AllDialogs = Dialogs.select() ldb.close() if not AllDialogs.exists(): Dialoge.append({ "name": "LOADING\nPLEASE WAIT", "chat_identification": "", "status": "", "timestamp": "", "data_dir": data_dir }) else: for dialog in AllDialogs: user_status = dialog.status #UserStatusOffline(was_online=datetime.utcfromtimestamp(1525351401)) if "UserStatusOnline" in user_status: #Online user_status = "green" lastonlinetime = "" else: if user_status == "UserStatusRecently()": # Was online Recently user_status = "orange" lastonlinetime = "" else: print("User Status is " + str(user_status)) user_status = "red" lastonlinetime = "" if "UserStatusOffline" in dialog.status: lastonlinetime = modules.BlueFunc.ElapsedTime( dialog.status.split( "UserStatusOffline(was_online=datetime.utcfromtimestamp(" )[-1].replace("))", "")) Dialoge.append({ "name": dialog.name, "chat_identification": dialog.identification, "status": user_status, "timestamp": lastonlinetime, "data_dir": data_dir }) #print("pyotherside.send(antwortGetDialogs, " + str(Dialoge) + ")") pyotherside.send("antwortGetDialogs", Dialoge) def reloadDialogs(self): print("reloadDialogs function in Main.py") try: Dialoge = [] for dialog in self.client.get_dialogs(): dialog_name = utils.get_display_name(dialog.entity) dialog_identification = dialog.entity.id try: dialog_status = dialog.entity.status except: dialog_status = "0" #print(" ") #print(dialog_name) #print(dialog.entity) #print(" ") Dialoge.append({"name": dialog_name, "status": dialog_status}) try: ldb.connect() except: True query = Dialogs.select().where( (Dialogs.identification == str(dialog_identification))) ldb.close() if not query.exists(): print("create Dialog entry " + dialog_name) threading.Thread(target=self.downloadProfilePhoto, args=[dialog.entity]) NewDialog = Dialogs.create( name=dialog_name, identification=dialog_identification, status=dialog_status, dialog=str(dialog)) NewDialog.save() else: # ToDO Test if changes #print("Dialog Changed " + dialog_name) ChangedDialog = Dialogs( name=dialog_name, identification=dialog_identification, status=dialog_status, dialog=str(dialog)) ChangedDialog.save() # if no Picture if not os.path.exists(data_dir + "/Pictures/Profiles/" + str(dialog_identification) + ".jpg"): threading.Thread(target=self.downloadProfilePhoto, args=[dialog.entity]).start() #print("Dialoge: " + str(Dialoge)) if not self.LastDialogList == Dialoge: self.LastDialogList = Dialoge self.getDialogs() except: print("getDialogs failed, no connection ?") self.tryConnect() def deleteProfilePhoto(self, id): print("deleteProfilePhoto(" + str(id) + ")") if os.path.exists(data_dir + "/Pictures/Profiles/" + str(id) + ".jpg"): os.remove(data_dir + "/Pictures/Profiles/" + str(id) + ".jpg") def downloadProfilePhoto(self, Entity): print("Start downloadProfilePhoto") print(" ") print(Entity) try: Image = self.client.download_profile_photo( Entity, file=data_dir + "/Pictures/Profiles/" + str(Entity.id), download_big=True) #if str(Image) == "None": self.deleteProfilePhoto(Entity.id) print("Image: " + str(Image)) except: print("downloadProfilePhoto failed no connection ?") self.tryConnect() def sendChat(self, message): try: ldb.connect() except: True MessageToSend = Uploads.create(text=message, chat_id=self.ChatPartnerID) MessageToSend.save() ldb.close() self.getChat() def trySending(self): try: try: ldb.connect() except: True query = Uploads.select() for messages in query: print("Sending (" + str(messages.id) + "): " + str(messages.text)) try: self.client.send_message(int(messages.chat_id), messages.text) messages.delete().execute() except: print("Error Sending") ldb.close() except: print("trySending failed, no connection ?") self.tryConnect() def getChat(self): print("getChat") ChatList = [] try: ldb.connect() except: True AllChats = Chats.select().where( Chats.chat_id == self.ChatPartnerID).order_by(Chats.identification) if not AllChats.exists(): ChatList.append({ "chattext": "LOADING\nPLEASE WAIT", "out": True, "sender": "Telepygram", "read": False, "media": "", "with_media": False }) else: for message in AllChats: if message.media == "": with_media = False media_is_video = False media_is_image = False else: with_media = True medianame = str(message.media).split("/")[-1] mediaformat = medianame.split(".")[-1] know_videos = ["ogv", "3gp"] if mediaformat in know_videos: media_is_video = True media_is_image = False else: media_is_video = False media_is_image = True ChatList.append({ "media_is_video": media_is_video, "media_is_image": media_is_image, "chattext": message.text, "out": message.out, "sender": message.user_name, "read": False, "media": message.media, "with_media": with_media }) query = Uploads.select().where( Uploads.chat_id == self.ChatPartnerID).order_by(Uploads.id) ldb.close() for MessageToUpload in query: ChatList.append({ "chattext": MessageToUpload.text, "out": True, "sender": "SENDING", "read": True, "media": "" }) if not self.LastChatList == ChatList or self.ChatForceReload: pyotherside.send("antwortGetChat", ChatList, self.ChatPartner) self.LastChatList = ChatList self.ChatForceReload = False else: print("LastChatList = ChatList") def reloadChat(self, LoadNewMessages): print("reloadChat") if True: #try: Dialog = GetFullUserRequest( self.client.get_entity(int(self.ChatPartnerID))) print("This Dialog " + str(Dialog)) print("LoadNewMessages: " + str(LoadNewMessages)) if LoadNewMessages: Messages = self.client.iter_messages(self.ChatPartner, limit=10) else: try: ldb.connect() except: True AllSavedMessages = Chats.select().where( Chats.chat_id == self.ChatPartnerID) SavedMessagesList = [] for msg in AllSavedMessages: SavedMessagesList.append(msg.identification) ldb.close() LastMessageLoaded = int(min(SavedMessagesList)) print("LastMessageLoaded: " + str(LastMessageLoaded)) Messages = self.client.iter_messages( self.ChatPartner, offset_id=LastMessageLoaded, limit=10) for message in Messages: try: ldb.connect() except: True print("message.id " + str(message.id)) query = Chats.select().where( Chats.identification == str(message.id)) ldb.close() if not query.exists(): print(message) print(" ") #print("User Name :" + str(self.client.get_entity(message.from_id))) names = [] try: user_firstname = str( self.client.get_entity(message.from_id).first_name) except: user_firstname = self.ChatPartner try: user_lastname = str( self.client.get_entity(message.from_id).last_name) except: user_lastname = "None" if not user_firstname == "None": names.append(user_firstname) if not user_lastname == "None": names.append(user_lastname) username = "******".join(names) message_text = message.message if message_text == None: message_text = "" print("action " + str(message.action)) if "MessageActionChatJoinedByLink" in str( message.action): message_text = "joined by invite link" if "MessageActionChatAddUser" in str(message.action): message_text = "joined" username_id = str(message.from_id) #print("username_id: " + username_id) try: message_media = str(message.media) except: message_media = "None" if not str(message_media) == "None": print("message_media: " + str(message_media)) file = data_dir + "/Media/" + str(message.id) try: file = self.client.download_media( message.media, file=file, progress_callback=None) message_media = file except: print("Error in Downlaod") else: message_media = "" NewChat = Chats.create(identification=message.id, chat_id=self.ChatPartnerID, user_name=username, user_id=username_id, text=message_text, out=message.out, media=str(message_media), total_message=message) NewChat.save() self.getChat()
all_c = alert_c + images_c all_c.sort() looking = 0 fout = open('tgimages.csv', 'w') for item in all_c: print("at", item[0], looking) if item[1] == "A": looking = 1 elif item[1] == "I": if looking: looking = 0 print("downloaded image post", item[0]) client.download_media(posts[item[0]].media, "./tg/images/" + str(item[0])) fout.write(str(item[0]) + "," + str(posts[item[0]].date) + "\n") else: looking = 0 print("downloaded image post backup", item[0]) client.download_media(posts[item[0]].media, "./tg/images/others/" + str(item[0])) looking = 0 else: print("Error")
for dialog in dialogs_content: audios = dialogs_content[dialog]["audios"] if (len(audios) > 0): #Prepare path to export audios_path = os.path.join(exports_folder, "audios", parse_file_name(dialog)) if not os.path.exists(audios_path): os.makedirs(audios_path) log("Exporting {} audios from \"{}\"...".format( len(audios), dialog)) for id, audio in enumerate(audios): client.download_media(audio, os.path.join(audios_path, str(id))) log("=====================================") log("") #Exporting photos if is_photos: log("Exporting photos...") log("=====================================") for dialog in dialogs_content: photos = dialogs_content[dialog]["photos"] if (len(photos) > 0): #Prepare path to export photos_path = os.path.join(exports_folder, "photos", parse_file_name(dialog))
try: fout = open('out/chat.xml', 'x') break except FileExistsError: get = input("Override out/chat.xml [y/n]?") if get == 'y' or get == 'Y': #delete os.remove('out/chat.xml') elif get == 'n' or get == 'N': #exit print("Bye.") exit(2) fout.write('<chat>\n') for c in chat: dl = saveMessage(c, fout, len(toDL), me.id) if dl != None: if dl.media != None: #here is something to download later toDL.append(DelayedDownload(len(toDL), c)) fout.write('</chat>\n') fout.close() createFolder('out/media/') print('Chat structure stored. Downloading Media - this may take a while!') for dl in toDL: print('.', end='') client.download_media(dl.message, "out/media/" + str(dl.id)) print('\n', len(toDL), " Media Files Downloaded.") print('End.')
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
# сюда перешел, свои вводные получил https://my.telegram.org api_id = 77777777 # свой получай api_hash = 'durovpriexalnasadovod' #тоже свой получай #укажи прокси, я поднял ssh туннель через putty client = TelegramClient('session_name', api_id, api_hash, proxy=(socks.SOCKS5, 'localhost', 5555)) phone_number = '+777777777777' #свой телефон вбивай client.connect() if not client.is_user_authorized(): client.send_code_request(phone_number) me = client.sign_in(phone_number, input('Enter code: ')) channel_username = sys.argv[1] # чат\канал # загружаем косарь сообщений. Можно увеличить/уменьшить msgs = client.get_messages(channel_username, 1000, filter=InputMessagesFilterDocument) for msg in msgs: if msg.media is not None: if os.path.exists('./'+channel_username+'/'+msg.media.document.attributes[0].file_name) and os.path.getsize('./'+channel_username+'/'+msg.media.document.attributes[0].file_name) == msg.media.document.size: print('File: '+ msg.media.document.attributes[0].file_name + ' exists and size is ok, skipping...') continue else: try: fn = msg.media.document.attributes[0].file_name.replace('\n',' ').replace('\r', '').replace('\\', ' ') client.download_media(msg,file='./'+channel_username+'/'+fn) except FloodWaitError as e: print('Flood waited for', e.seconds) quit(1) print('Downloaded file: '+ msg.media.document.attributes[0].file_name) print('Downloading complete')
def download_media(pSection_config): if not 'name' in pSection_config: logging.error('The Section Name not especified! Aborting section') return ## Geting download path if not 'download_path' in pSection_config: lDownload_path = gDownload_path + '/' + pSection_config['name'] else: lDownload_path = pSection_config['download_path'] if lDownload_path[1] != '/': lDownload_path = gRoot_path + lDownload_path if not os.path.isdir(lDownload_path): os.mkdir(lDownload_path) logging.info('Creating Download Dir: ' + lDownload_path) else: logging.info('Using Download Dir: ' + lDownload_path) lDownload_path = lDownload_path + '/' if lDownload_path[-1] != '/' else '' lApi_id = pSection_config[ 'api_id'] if 'api_id' in pSection_config else gApi_id lApi_hash = pSection_config[ 'api_hash'] if 'api_hash' in pSection_config else gApi_hash lPhone_number = pSection_config[ 'phone_number'] if 'phone_number' in pSection_config else gPhone_number if not (lApi_hash and lApi_id and lPhone_number): logging.error('Authentication data not Set!') logging.error('Stopping import for' + pSection_config['name']) return if not 'channel_username' in pSection_config or not pSection_config[ 'channel_username']: logging.warning('Channel User Name not valid for ' + pSection_config['name']) return lSession_name = lPhone_number[1:] lLimit = int(pSection_config['messages_limit'] ) if 'messages_limit' in pSection_config else 10 lExtensions = pSection_config[ 'filter'] if 'filter' in pSection_config else None lTimestamp_name = pSection_config[ 'timestamp_name'] if 'timestamp_name' in pSection_config else gTimestamp_name # Log in to Telegram and create a client object to use for getting data # Create the client and connect client = TelegramClient(lSession_name, lApi_id, lApi_hash) client.start() logging.info("Client Created") # Ensure you're authorized if not client.is_user_authorized(): logging.info('Requesting new Code!') client.send_code_request(lPhone_number) try: logging.info('Gettign from user new telegram code') client.sign_in(lPhone_number, input('Enter the code: ')) except SessionPasswordNeededError: logging.info('Getting MFA Password') client.sign_in(password=input('Password: '******'Starting get Messages one by one') #Get last "messages_limit" messages from channel/group lItemsCount = 0 for msg in client.get_messages(pSection_config['channel_username'], limit=lLimit): if msg.media is not None: if lExtensions: if msg.file.ext in lExtensions: logging.info(msg.sender.title, msg.text) lMediaFile = msg.file.name if lMediaFile == None: lMediaFile = lDownload_path + msg.file.media.date.strftime( '%Y-%m-%d_%I-%M-%S') + msg.file.ext else: if lTimestamp_name: lMediaFile = lDownload_path + msg.file.media.date.strftime( '%Y-%m-%d_%I-%M-%S-') + lMediaFile else: lMediaFile = lDownload_path + lMediaFile logging.info('Download File: ' + lMediaFile) if os.path.isfile(lMediaFile): localSize = os.path.getsize(lMediaFile) remoteSize = msg.file.size if localSize < remoteSize: logging.info('Deleting incompleted Download!') os.remove(lMediaFile) else: logging.info( 'Skiping Download: File already exists!') continue client.download_media(message=msg, file=lMediaFile) lItemsCount += 1 else: logging.info('Ignoring Media "' + msg.text + '" due Filter Config') logging.info('Finish process') logging.info('Items Downloaded: ' + str(lItemsCount))