def ritorna_lista_membri_gruppo(self, chat_id, username_gruppo): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) client = TelegramClient('session', API_ID, API_HASH) client.start(bot_token=TOKEN) try: dati = list(client.get_participants(username_gruppo, aggressive=True)) except: self.bot.sendMessage(chat_id,"C'è stato un problema con il bot si prega di riprovare") client.disconnect() loop.stop() loop.close() return [] lista_gruppo=[] for utente in dati: if not utente.bot: user=self.ritorna_utente(chat_id, utente.id, utente.first_name) lista_gruppo.append(user) client.disconnect() loop.stop() loop.close() return lista_gruppo
class Forwarder: def __init__(self, config): self.telegram = TelegramClient(StringSession(config.session), config.api_id, config.api_hash) self.message_pattern = config.message_pattern self.input_chat_usernames = config.input_chat_usernames self.output_chat_usernames = config.output_chat_usernames self.input_chats = [] self.output_chats = [] def start(self): self.__connect() self.__load_input_chats() self.__load_output_chats() self.__start_forwarding() def __connect(self): self.telegram.start() def __load_input_chats(self): dialogs = self.telegram.get_dialogs() for username in self.input_chat_usernames: dialog = next( filter(lambda e: e.entity.username == username, dialogs), None) if dialog: self.input_chats.append( InputChannel(dialog.entity.id, dialog.entity.access_hash)) else: raise RuntimeError(f"Input chat '{username}' was not found") def __load_output_chats(self): dialogs = self.telegram.get_dialogs() for username in self.output_chat_usernames: dialog = next( filter(lambda e: e.entity.username == username, dialogs), None) if dialog: self.output_chats.append( InputChannel(dialog.entity.id, dialog.entity.access_hash)) else: raise RuntimeError(f"Output chat '{username}' was not found") def __start_forwarding(self): @self.telegram.on( events.NewMessage(chats=self.input_chats, pattern=self.message_pattern)) async def handler(event): logger.info("Forwarding 1 message") for output_chat in self.output_chats: await self.telegram.forward_messages(output_chat, event.message) logger.info(f"Listening on {len(self.input_chats)} chats.") logger.info(f"Forwarding messages to {len(self.output_chats)} chats.") self.telegram.run_until_disconnected()
def send_message_to_channel() -> None: with open('setting.json', 'r', encoding='utf') as out: setting = json.load(out) client = TelegramClient('session', setting['account']['api_id'], setting['account']['api_hash']) client.start() dialog = setting['channel']['name'] messages = client.get_messages(dialog, limit=None) messages = [message for message in messages \ if message.date.strftime('%m-%d-%Y') == datetime.now().strftime('%m-%d-%Y')] fcoins_sum = [] rub_sum = [] for message in messages: try: fcoins_sum.append(float(search_sum(message.message))) except: pass try: rub_sum.append(float(search_money(message.message))) except: pass client.send_message('https://t.me/joinchat/AAAAAEAi2H_K_1rud0aFig', f'Сводка за 24 часа:') client.send_message( 'https://t.me/joinchat/AAAAAEAi2H_K_1rud0aFig', f'Кол-во Fcoins: {sum(fcoins_sum)},\nСумма: {sum(rub_sum)}₽')
def fill_list(self, api_id, api_hash, data, proxy=None): entries = {} client = TelegramClient('anon', api_id, api_hash, proxy=proxy) client.start() for category in data['entries']: entries[category] = {} for entry in data['entries'][category]: channel_request = GetFullChannelRequest(channel=entry['link']) channel = client(channel_request) description = channel.full_chat.about.replace('\n', ' \n ') pinned = False if 'pinned' not in entry else entry['pinned'] tags = None if 'tags' not in entry else entry['tags'] entry = ListEntry( url=entry['link'], title=channel.chats[0].title, description=description, subscribers=channel.full_chat.participants_count, pinned=pinned, tags=tags) for tag in entry.tags: tagname = tag if tag not in data['tags'] else data['tags'][ tag]['title'] if tagname not in entries[category]: entries[category][tagname] = [] entries[category][tagname].append(entry) return entries
def start_sync(): """Start tgcf live sync.""" # pylint: disable=import-outside-toplevel from telethon.sync import TelegramClient, functions, types client = TelegramClient(config.SESSION, config.API_ID, config.API_HASH) client.start(bot_token=config.BOT_TOKEN) is_bot = client.is_bot() for key, val in ALL_EVENTS.items(): if key.startswith("bot"): if not is_bot: continue if config.CONFIG.live.delete_sync is False and key == "deleted": continue client.add_event_handler(*val) logging.info(f"Added event handler for {key}") if is_bot and const.REGISTER_COMMANDS: client( functions.bots.SetBotCommandsRequest( commands=[ types.BotCommand(command=key, description=value) for key, value in const.COMMANDS.items() ] ) ) client.run_until_disconnected()
def main(args): config = get_user_config(args.config_file) client = TelegramClient(**config) client.start() with client: client.loop.run_until_complete( process_url(client, args.channel_url, args.output_file))
def main() -> None: from telethon.sync import TelegramClient, functions client = TelegramClient("set online", api_id=API_ID, api_hash=API_HASH) client.start() set_online = functions.account.UpdateStatusRequest(offline=False) client(set_online)
def initialize(api_id, api_hash): try: os.mkdir('downloaded_media') except: pass client = TelegramClient('media_downloader', api_id, api_hash) client.start() return client
def get_posts_complex(self, query): """ Execute a query; get messages for given parameters :param dict query: Query parameters, as part of the DataSet object :return list: Posts, sorted by thread and post ID, in ascending order """ self.eventloop = asyncio.new_event_loop() session_path = Path(__file__).parent.joinpath( "sessions", self.dataset.parameters.get("session")) client = None try: client = TelegramClient(str(session_path), self.dataset.parameters.get("api_id"), self.dataset.parameters.get("api_hash"), loop=self.eventloop) client.start() except Exception as e: self.dataset.update_status( "Error connecting to the Telegram API with provided credentials.", is_final=True) self.dataset.finish() if client and hasattr(client, "disconnect"): client.disconnect() return None # ready our parameters parameters = self.dataset.get_parameters() queries = [ query.strip() for query in parameters.get("query", "").split(",") ] max_items = convert_to_int(parameters.get("items", 10), 10) # userinfo needs some work before it can be retrieved, something with # async method calls userinfo = False # bool(parameters.get("scrape-userinfo", False)) try: posts = self.gather_posts(client, queries, max_items, userinfo) except Exception as e: self.dataset.update_status("Error scraping posts from Telegram") self.log.error("Telegram scraping error: %s" % traceback.format_exc()) posts = None finally: client.disconnect() # delete personal data from parameters. We still have a Telegram # session saved to disk, but it's useless without this information. self.dataset.delete_parameter("api_id") self.dataset.delete_parameter("api_hash") self.dataset.delete_parameter("api_phone") return posts
def script_work(): global client admin_client = TelegramClient(username, api_id, api_hash) admin_client.start(phone, password) with admin_client as client: admin_client.get_entity("ChatWarsBot") client.add_event_handler(stats_handler, event=events.NewMessage) print("telegram script launched") admin_client.run_until_disconnected()
def client(g_bot: GDGAjuBot): # Esse módulo só pode ser testado com uma chave API real # Obtenha a sua em https://my.telegram.org, na seção API Development api_id = TELEGRAM_CLIENT_API_ID api_hash = TELEGRAM_CLIENT_API_HASH t_client = TelegramClient("it_gdgajubot", api_id, api_hash) t_client.start() yield ClientWrapper(t_client, g_bot.get_me().name) t_client.disconnect()
def main(id, hash, target, mime, limit, output): client = TelegramClient('telegram-files-downloader', id, hash) client.start() count = 0 print('[INFO] - Started downloading files to {}'.format(output)) for message in client.iter_messages(target): if count > limit: break if message.media is not None: client.download_media(message=message, file=output) count += 1 print('[INFO] - Ended downloading files')
def start(): client = TelegramClient('parser', config.api_id, config.api_hash) @client.on(events.NewMessage(chats=(config.chats_name))) async def normal_handler(event): # print(event.message.from_id) for key in config.keys: if key in event.message.to_dict()['message']: await client.forward_messages(config.source, event.message, event.message.from_id) client.start() client.run_until_disconnected()
def script_work(): global client global loop loop = asyncio.get_event_loop() admin_client = TelegramClient(username, api_id, api_hash) admin_client.start(phone, password) with admin_client as client: client = admin_client admin_client.get_entity("ChatWarsBot") start_updating() start_countdown() print("started timer") #timer = Timer(interval=5, function=update_guild_stats, args=[client, True]).start() admin_client.run_until_disconnected()
class BaseTelegramCrawler(BaseCrawler): """ Базовый краулер для телеграмм-каналов """ def __init__(self, base_url='', base_account_folder='', limit=1000): super().__init__(base_url, base_account_folder) # Устанавливаем лимит получаемых с канала сообщений self.limit = limit # Получаем необходимые настройки _settings = get_settings() # Присваиваем значения настроек внутренним переменным _api_id = _settings['api_id'] _api_hash = _settings['api_hash'] _username = _settings['username'] # Создаем объект клиента Telegram API self.client = TelegramClient(_username, _api_id, _api_hash) # Запускаем клиент self.client.start() def set_base_url(self, url): """ Метод, устанавлявающий базовый урл, который парсится :param url: :return: """ self.base_url = url def get_messages(self): """ Возвращаем экземпляр класса Message при итерировании :return: Message """ for message in self.client.iter_messages(self.base_url, limit=self.limit): yield Message(self.base_url, message.text, datetime_=message.date) # Функция для отправки сообщения в определенный чат def send_message_to_chat(self, chat, message): self.client.send_message(chat, message.description)
class client: def __init__(self, session, api_id, api_hash): self.client = TelegramClient(session, api_id, api_hash) self.client.start() def scrape(self, chat, from_peer, limit, filter, offset_date=datetime.now()): #set limit under 2000 to avoid hitting flood wait global Filter chat_entity = self.client.get_entity(chat) from_peer_entity = self.client.get_entity(from_peer) for i in range(math.ceil(limit/100)): try: total = self.client.get_messages(from_peer_entity, limit=100, offset_date=offset_date, filter=Filter[filter]) self.client.forward_messages(chat_entity, total) print(total[-1].date) except FloodWaitError as e: print(e) wait_time = int(re.findall('\d+',str(e))[0]) time.sleep(wait_time) continue
class BotController: def __init__(self, session_name=SESSION_NAME): self.client = TelegramClient(session_name, API_KEY, API_HASH) def __enter__(self): self.client.__enter__() return self def __exit__(self, exc_type, exc_val, exc_tb): self.client.__exit__(exc_type, exc_val, exc_tb) def start(self): self.client.loop.run_until_complete(import_modules(self.client)) @self.client.on(NewMessage(outgoing=True)) async def message(event: NewMessage.Event): await handle_message(event.message) self.client.start() self.client.run_until_disconnected()
def main(): parser = ArgumentParser() set_arguments(parser) args = parser.parse_args() client = TelegramClient("tele_session", args.api_id, args.api_hash) client.start() prev_update_time = "" while True: if time_has_changed(prev_update_time): generate_and_save_quote() prev_update_time = convert_time_to_string(datetime.now()) # client(DeletePhotosRequest(client.get_profile_photos('me'))) client(DeletePhotosRequest(client.get_profile_photos('me', limit=1))) path_to_file = os.getcwd() + f"/src/quote_images/new_quote.jpg" file = client.upload_file(path_to_file) client(UploadProfilePhotoRequest(file)) time.sleep(1)
def authenticate(self, path=None): if self.session_file is None: if path is None: raise ValueError("Argument 'path' cannot be None") session_file = os.path.join(path, 'tgscrape.session') err_msg = 'Cannot authenticate with Telegram API: ' try: client = TelegramClient(self.session_file, self.api_id, self.api_hash) client.start() except PhoneNumberInvalidError as e: raise ValueError(err_msg + 'invalid phone number!') except RuntimeError as e: raise ValueError(err_msg + 'invalid code provided!') except Exception as e: raise Exception(err_msg + '%s!' % type(e)) else: self.client = client
def main(): if not path.isfile(config.sessions): os.makedirs(path.dirname(config.sessions), exist_ok=True) open(config.sessions, 'w').close() cfg = ConfigParser() cfg.read(config.sessions) session = input('Session: ') assert session not in cfg.sections() cfg.add_section(session) api_id = input('API ID: ') cfg[session]['api_id'] = api_id api_hash = input('API Hash: ') cfg[session]['api_hash'] = api_hash with open(config.sessions, 'wt') as file: cfg.write(file) client = TelegramClient(f'./sessions/{session}', api_id, api_hash) client.start() client.disconnect()
def get_telegram_token(name: str) -> str: from telethon.sync import TelegramClient, events client = TelegramClient('get_new_bot_token', 1170703, '57ce76b0fed0ae5e8103fb42e20021ba') token = "" @client.on(events.NewMessage(chats=('BotFather', ))) async def handle_token(event): nonlocal token msg = event.message.to_dict()['message'] if 'Done! Congratulations on your new bot' in msg: start = msg.index('Use this token to access the HTTP API:') + len( 'Use this token to access the HTTP API:') + 1 token = msg[start:start + 46] client.start() client.send_message('BotFather', '/start') client.send_message('BotFather', '/newbot') client.send_message('BotFather', name) client.send_message('BotFather', name + 'UglyBotlingBot') if token: return token return "smth"
# классы для работы с каналами from telethon.tl.functions.channels import GetParticipantsRequest from telethon.tl.types import ChannelParticipantsSearch # класс для работы с сообщениями from telethon.tl.functions.messages import GetHistoryRequest config = configparser.ConfigParser() config.read('config.ini') api_id = config['Telegram']['api_id'] api_hash = config['Telegram']['api_hash'] username = config['Telegram']['username'] client = TelegramClient(username, api_id, api_hash) client.start() async def dump_all_participants(channel): offset_user = 0 limit_user = 100 all_participants = [] filter_user = ChannelParticipantsSearch('') while True: participants = await client( GetParticipantsRequest(channel, filter_user, offset_user, limit_user, hash=0))
except KeyError: return web.Response(status=422, body='mission required param username') if not username: return web.Response(status=422, body='username param can not be empty') result = await handle(username) if result: return web.Response(status=200, body='ok') else: return web.Response(status=400, body='bot offline') async def handle(username): logging.info(username) chat = await client.get_input_entity(username) async with client.conversation(chat) as conv: await conv.send_message("/ping") answer = await conv.get_response() return bool(answer.raw_text) if __name__ == '__main__': logging.basicConfig(level=logging.INFO) logging.info('start application') client.connect() client.start(phone=telephone) app = web.Application() app.add_routes([web.post('/', handle_post), web.get('/', handle_get)]) web.run_app(app, port=8080) client.disconnect()
done = False try: api_info_list = read_csv('api.csv') phone_list = sum(read_csv('phone.csv'), start=[]) config = configparser.ConfigParser() config.read("config.ini") from_channel = config['Telegram']['from_channel'] to_channel = config['Telegram']['to_channel'] export_phone = utils.parse_phone(config['Telegram']['export_phone']) user_rows = read_csv('users.csv') main_client = TelegramClient(f"sessions/{export_phone}", *api_info_list[0]) main_client.start(export_phone) from_channel_entity = main_client.get_entity(from_channel) to_channel_entity = main_client.get_entity(to_channel) try: for api in api_info_list: print(f"\n*** Using App {api[0]} ***\n") for unparsed_phone in phone_list: phone = utils.parse_phone(unparsed_phone) client = TelegramClient(f"sessions/{phone}", *api) client.start(phone) # Join channels channels_joined = all([
print( f""" .................................. > www.arshmaan.com < .................................. """) try: config = configparser.ConfigParser() config.read("config.ini") channel = config['Telegram']['from_channel'] phone = utils.parse_phone(config['Telegram']['main_phone']) api = read_csv('api.csv')[0] client = TelegramClient(f"sessions/{phone}", *api) client.start(phone) rows = [['ID', 'Name', 'Username', 'Phone']] print("Getting participants...") for participant in client.iter_participants(channel, aggressive=True): print(f"Got {len(rows)}", end='\r') rows.append([ participant.id, utils.get_display_name(participant), participant.username, participant.phone ]) print("\nWriting output") write_csv('users.csv', rows)
import json import time import socks from telethon.sync import TelegramClient if __name__ == "__main__": api_id = None api_hash = '' client = TelegramClient('tgcrawler', api_id, api_hash) client.start(phone='') print(client.is_user_authorized()) req_count = 200 sh_id = None file_name = 'sh_messages_tg.json' messages = [] loaded = 0 try: d = json.load(open(file_name, encoding='utf-8')) messages = d['items'] loaded = d['items'][-1]['id'] except: print('No file, create new') messages = [] process = True # msg_it = client.iter_messages(sh_id, limit=200000) min = loaded max = loaded + req_count
class TelegramStrategy(strategy): """ """ strategyName = 'Telegram' channel = None orders = [] telegramClient = None message = None apiID = None apiSecret = None def __init__(self): self.importAPIKeys() self.telegramClient = TelegramClient('kcapbot', self.apiID, self.apiSecret) self.telegramClient.connect() logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') print("Telegram Account authorized:\nListening for Alerts\n\n") def listen(self): """ """ @self.telegramClient.on(events.NewMessage) async def my_event_handler(event): print(event.raw_text) parseMessage(self, event.raw_text) self.telegramClient.start() self.telegramClient.run_until_disconnected() def importAPIKeys(self): """ """ f = open('strategies/Telegram/TelegramCredentials.json', 'r') with open(f.name) as jsonFile: data = json.load(jsonFile) for keySet in data['API_Keys']: if keySet['keyID'] is not 'Fake': self.apiID = keySet['keyID'] self.apiSecret = keySet['privateKey'] else: print('PLEASE ADD TELEGRAM API KEYS TO Telegram/TelegramCredentials.json\n') def runStrategy(self, marketControllers): """ :param marketControllers: """ return self.orders def addOrder(self, order): """ :param order: """ self.orders.append(order)
class UploadTelegramCrawler(BaseCrawler): """ Краулер, выгружающий данные из телеграмм-каналов """ def __init__(self, base_url, base_account_folder, limit=1000): super().__init__(base_url, base_account_folder) # Устанавливаем лимит получаемых с канала сообщений self.limit = limit # Получаем необходимые настройки _settings = get_settings() # Присваиваем значения внутренним переменным _api_id = _settings['api_id'] _api_hash = _settings['api_hash'] _username = _settings['username'] # Создадим объект клиента Telegram API self.client = TelegramClient(_username, _api_id, _api_hash) def __enter__(self): # Запускаем клиент self.client.start() return self def __exit__(self, type, value, traceback): """ Отключаем клиента :param type: :param value: :param traceback: :return: """ self.client.disconnect() def get_messages(self): """ Возвращаем экземпляр класса Message при итерировании :return: Message """ for message in self.client.iter_messages(self.base_url, limit=self.limit): yield Message(self.base_url, message.text, datetime_=message.date) def upload_to_csv(self): # Поля таблицы field_names = ['Text', 'Date'] # Путь к csv файлу csv_path = self.base_account_folder + self.base_url.split('/')[-1] + '.csv' # Открываем csv файл with open(csv_path, 'w', encoding='utf-8') as csv_file: # Инициализация экземляра DictWriter csv_writer = csv.DictWriter(csv_file, fieldnames=field_names) csv_writer.writeheader() # Итерируемся по сообщениям for message in self.get_messages(): if message.description: # Записываем один ряд таблицы csv_writer.writerow({'Text': message.description, 'Date': message.datetime_})
import os from telethon.sync import TelegramClient from src.Channel import Channel from src.channelUpdate import channelUpdate config = configparser.ConfigParser() config.read("Config.ini") api_id = config['Telegram']['api_id'] api_hash = config['Telegram']['api_hash'] session = config['Telegram']['session'] if __name__ == '__main__': TelegramClientInstance = TelegramClient(session=session, api_id=api_id, api_hash=api_hash) TelegramClientInstance.start() channelConfigFilesFolder = "./src/channelConfig/" channelList = [Channel(channelConfigFilesFolder + config) for config in os.listdir(channelConfigFilesFolder) if config.endswith(".json")] while True: for channel in channelList: channelUpdate(channel, TelegramClientInstance, maxDurationInSeconds=720) print("sleep.... 360sec") sleep(360)
def conect(): #config api_id = "1265435" api_hash = '17e1fd69156fa33ec73960a5806b4897' client = TelegramClient('sessiong_name', api_id, api_hash) #group_name = {'Các thánh than cà khịa','Chợ Bitcoin Hà Nội'} listCoin = {'ETH', ' B', 'BTC', 'U', 'USDT', 'BIT', 'E'} try: @client.on(events.NewMessage(chats=None)) async def handler(event): # Good try: chat = await event.get_chat() #print(chat) sender = await event.get_sender() print("GroupID:", str(chat.id), "Group_name: ", str(chat.title), "UserName: "******" --- Chat: ", str(event.raw_text)) list_record = list() list_chat = processMessage(event.raw_text, listCoin) print(list_chat) num_record = 0 for i in range(10): if ("Quanlity" + str(num_record)) in list_chat and ( "CoinType" + str(num_record)): recorddb = dict() recorddb['Groupid'] = chat.id recorddb['GroupName'] = chat.title recorddb['UserName'] = sender.username recorddb['UserID'] = sender.id recorddb['UserPhone'] = sender.phone recorddb['Chat'] = event.raw_text recorddb['action'] = list_chat['action'] recorddb['Quanlity'] = list_chat['Quanlity' + str(num_record)] recorddb['CoinType'] = list_chat['CoinType' + str(num_record)] list_record.append(recorddb) #### # send thist record to database >>> list_record ''' myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] ----recorddb is dict() type recorddb = {'Groupid': 1135988787, 'GroupName': 'Chợ Bitcoin Hà Nội', 'UserName': '******', 'UserID': 155296816, 'UserPhone': None, 'Chat': 'Bán 60 eth giá tốt', 'action': 'Sell', 'Quanlity': '60', 'CoinType': 'ETH'} x = mycol.insert_one(recorddb) ''' #### print("Recrod to database ", recorddb) num_record = num_record + 1 #sender = await ev81ent.get_sender() #print("send_information:", se nder) #print (str(processMessage(event.raw_text,listCoin))) print("-------------") #chat_id = event.chat_id except Exception as identifier: pass except Exception as identifier: pass #client.conversation() client.start() client.run_until_disconnected()