def client_job(id_to_send, msg_to_send, gr): """does a client.start and send the messages to the needed ppl""" client = TelegramClient(tlt_conf.sess, tlt_conf.api_id, tlt_conf.api_hash) client.start() deelay = 0 with client: client.get_participants(gr[0]) for i in range(0, len(iD_to_send)): try: client.send_message(int(id_to_send[i]), str(msg_to_send[i].encode('cp1251'))) time.sleep(deelay) except ValueError: file = open('log.txt', 'a') # a = append file.write("User" + " " + str(id_to_send[i]) + " " + "is deleted" + " " + str(datetime.datetime.now()) + "\n") file.close() pass except PeerFloodError: file = open('log.txt', 'a') # a = append file.write( "U r having some sending problems (maybe u r currently banned for spam)" + " " + str(datetime.datetime.now()) + "\n") file.close() pass
def get_participants_hash(api_id: int, api_hash: str, channel_id: int): client = TelegramClient('session_name', api_id, api_hash) try: client.start() return str(client.get_participants(channel_id)) finally: client.disconnect()
def main(): api_id = os.environ.get('API_ID') api_hash = os.environ.get('API_HASH') client = TelegramClient('kolya', api_id, api_hash) client.start() print('Start find clients') participants = client.get_participants('u_job') ids = list(map(lambda x: x.id, participants)) print('I findes {} clients'.format(len(ids))) text = 'Добрый день.\n\nНаша команда разработала замечательного бота для '\ 'поиска работы: @RS_Work_bot\n\nВы можете создавать в нём свои ' \ 'вакансии, или искать работу.\n\nМы учли все недостатки' \ ' существующих ботов в телеграм, и создали очень удобного' \ ' и просто бота.' print('I start the newsletter') count = len(ids) counter = 0 def _send(ids): for send_id in ids[60:]: nonlocal counter counter += 1 print('I send to client msg') user = client.get_entity(PeerUser(send_id)) sec = 5 try: client.send_message(user, text) except FloodWaitError as error: sec = int(str(error).split(' ')[3]) print('FLOOD, please sleep {}'.format(sec)) except PeerFloodError as error: print(str(error)) sleep(5) nonlocal count count -= 1 print('Отправлено: {}'.format(counter)) print('Осталось отправить: {}'.format(count)) print('I sleep 5 seconds') sleep(sec) print('continue') return print('I finished the newsletter') return _send(ids)
class TelethonWorker: def __init__(self, api, hash_, number, password, proxy, getCodeFunc): self.api_id = api self.api_hash = hash_ self.proxy = proxy proxy_ip = self.proxy.split(':')[0] port = self.proxy.split(':')[1] self.getCode = getCodeFunc self.number = number self.session = number self.password = password self.app = TelegramClient(self.session, self.api_id, self.api_hash, proxy=(socks.SOCKS5, str(proxy_ip), int(port))) self.app.run_until_disconnected() self.app.start(phone=self.number, password=self.password, code_callback=self.getCode) # self.app.start() def getListMembers(self): users = [] for dialog in self.app.get_dialogs(): if (dialog.is_group and type(dialog.draft.entity).__name__ == "Channel"): time.sleep(10) chatUser = self.app.get_participants(dialog, aggressive=True) for user in chatUser: if (not (user.bot or user.is_self or user.deleted)): users.append(user) return self.saveListUsers(users) def saveListUsers(self, arr): f = open('users.txt', 'w') for i in arr: username = "******" + i.username if i.username is not None else "-" f.write(str(i.id) + "\t" + username + '\n') f.close() return len(arr)
def user_status(api_id, api_hash, group_name): """ This function can be used to get users who was active in last 24 hours :param api_id: Your API ID :param api_hash: Your API hash :param group_name: group/channel name :return: pandas DataFrame """ client = TelegramClient('session_name', api_id, api_hash).start() participants = client.get_participants(group_name) time_limit = (datetime.utcnow() - timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S') user_name = [] user_status = [] if len(participants): for x in participants: try: if str(x.status).startswith('UserStatusRecen'): user_name.append(x.first_name) user_status.append('recently') elif str(x.status).startswith('UserStatusOnline'): user_name.append(x.first_name) user_status.append('online') elif x.status.was_online.strftime( '%Y-%m-%d %H:%M:%S') >= time_limit: user_name.append(x.first_name) user_status.append( x.status.was_online.strftime('%Y-%m-%d %H:%M:%S')) else: pass except: pass df = pd.DataFrame({'User': user_name, 'status': user_status}) print('Number of active users in last 24 hours is {}.'.format(df.shape[0])) print(df.head(5))
def main(): global client global user_dialogs client = TelegramClient(PHONE.strip('+'), TG_API_ID, TG_API_HASH, proxy=None, update_workers=4, spawn_read_thread=False) client.start() if not client.is_user_authorized(): client.send_code_request(PHONE) client.sign_in(PHONE, input("Enter code: ")) user_dialogs = client.get_dialogs() group = search_entities("Bmsklad") for participant in client.get_participants(group): print( f"{participant.username}, {participant.first_name} {participant.last_name}" )
def main(): # Get ENV variables from the '.env' file load_dotenv() api_id = os.getenv('API_ID') api_hash = os.getenv('API_HASH') phone = os.getenv('PHONE') fileName = input("Enter the File Name: ") fileName = fileName + '.csv' client = TelegramClient(phone, api_id, api_hash) client.connect() if not client.is_user_authorized(): client.send_code_request(phone) client.sign_in(phone, input('Enter the OTP: ')) groups_list = [] group = {} # Get's a List of Dictionaries with Group name with Group ID for d in client.get_dialogs(): try: if d.is_group and not d.is_channel and d.name != '': group = { "id": d.entity.id, "title" : d.entity.title } groups_list.append(group) except: continue # Create a CSV file with open(fileName, mode="w",encoding='UTF-8') as f: writer = csv.writer(f,delimiter=",",lineterminator="\n") writer.writerow(['username', 'first_name', 'last_name', 'phone','group', 'user_id', 'group_id']) # Extract Users from the Group for group_name in groups_list: # Iterates over List of Dictionaries to extract Users # Output CSV file has:- username, first_name, last_name, phone, group, user_id, group_id target_group = group_name all_participants = [] all_participants = client.get_participants(target_group["title"]) print('Fetching Members from {}\nWriting to the file'.format(target_group["title"])) with open(fileName, mode="a", encoding='UTF-8') as f: writer = csv.writer(f, delimiter=",", lineterminator="\n") for user in all_participants: if user.username: username = user.username else: username = "" if user.first_name: first_name = user.first_name else: first_name = "" if user.last_name: last_name = user.last_name else: last_name = "" if user.phone: phone = user.phone else: phone = "" if user.id: user_id = user.id else: user_id = "" if target_group["title"]: group = target_group["title"] else: group = "" if target_group["id"]: group_id = target_group["id"] else: group_id = "" writer.writerow([username, first_name, last_name, phone, group, user_id, group_id]) print('All Group Members are scraped successfully.')
from telethon import TelegramClient from telethon.tl.functions.channels import JoinChannelRequest from telethon.tl.functions.channels import GetFullChannelRequest #from telethon.tl.functions.channels import get_participants api_id = 3409046 api_hash = '48ae9fbdf79edda291e1fa5796fc4665' client = TelegramClient('anon', api_id, api_hash) entity = client.get_entity("t.me/micanaljc") #omit @ channel = "@micanaljc" # get all the users and print them for u in client.get_participants(channel): print(u.id, u.first_name, u.last_name, u.username) #with TelegramClient('sessionname', api_id, api_hash) as client: #r = client(functions.channels.JoinChannelRequest(channel='@pruebastienda')) #print(r)
api_id = your API ID api_hash = 'Your API Hash' phone_number = 'Registered mobile number with country code' channel_username = '******' # Channel name can be found in channel link (https://t.me/CHANNEL_NAME) # --------------------------------------------------------------------------------------------- client = TelegramClient('session_name', api_id, api_hash).start() # You will be asked to enter your mobile number- Enter mobile number with country code # Enter OTP (For OTP check Telegram inbox) # ====================================================================================================================== # Getting user details # ====================================================================================================================== participants = client.get_participants(channel_username) # This code can be used to extracted upto 10k user's details # Let's get first name, last name and username # --------------------------------------------------------------------------------------------- firstname =[] lastname = [] username = [] if len(participants): for x in participants: firstname.append(x.first_name) lastname.append(x.last_name) username.append(x.username) # ---------------------------------------------------------------------------------------------
if d.is_channel} channel_name = 'SuperGrupoPortalRubemGonzalez' # choose the one that I want list users from channel = channels[channel_name] dialogs = client.get_dialogs() # get all the users and print them #for u in client.get_participants(dialogs[3].entity,limit=0): # print(u.id, u.first_name, u.last_name, u.username, u.access_hash) #for u in client.get_participants(channel): # print(u.id, u.first_name, u.last_name, u.username, u.access_hash) #for i in channels: # print(i) #for u in dialogs: # print(u) for u in dialogs: print(u.name) print(dialogs[3]) for u in client.get_participants(dialogs[3].entity,aggressive=True): print(u.username, u.first_name, u.last_name, u.username, u.id, u.access_hash) print(client.get_participants(dialogs[3].entity,limit=0).total)
number_of_Groups = int(input('How much groups you want to Add ')) for i in range(number_of_Groups): i=0 for group in groups: print(str(i) + '- ' + group.title) i+=1 Target_group = result[int(input('Chose number of gropup '))] try: for key in queryKey: offset = 0 limit = 10000 limit=None makeList(client_1(GetParticipantsRequest(Target_group, ChannelParticipantsSearch(key), offset, limit=10000 ,hash=0))) makelist(client_1.get_participants(Target_group.title, aggressive = True)) #Передаем список следующему методу #Передаем список следующему методу except Exception as e: print(type(e)) print(e) continue print('Users lenght - ',len(Users))
from telethon import TelegramClient, sync api_id = '<your API>' api_hash = '<your API>' # 149.154.167.50:443 client = TelegramClient('<appname>', api_id, api_hash).start() # get all the channels that I can access groups = {d.entity.title: d.entity for d in client.get_dialogs() if d.is_group} group_array = ['<your groups>', ''] # d.entity est une instance de chat # print(groups) # choose the one that I want list users from for name in group_array: group = groups[name] print('\n\n\n###### GROUPE : ' + name) print('- group name : ' + str(group.id)) # get all the users and print them for u in client.get_participants(group): print(u.id, u.first_name, u.last_name, u.username)
continue print('[+] Выберите группу, чтобы спиздить участников :') i = 0 for g in groups: print('[' + str(i) + ']' + ' - ' + g.title) i += 1 print('') g_index = input("[+] Введите номер : ") target_group = groups[int(g_index)] print('[+] Выборка участников...') time.sleep(1) all_participants = [] all_participants = client.get_participants(target_group, aggressive=True) print('[+] Сохранение в файл...') time.sleep(1) with open("members.csv", "w", encoding='UTF-8') as f: writer = csv.writer(f, delimiter=",", lineterminator="\n") writer.writerow([ 'username', 'user id', 'access hash', 'name', 'group', 'group id' ]) for user in all_participants: if user.username: username = user.username else: username = "" if user.first_name:
client = TelegramClient(api_id, api_id, api_hash, proxy=(proxy_host, proxy_port, proxy_secret), connection=connection.tcpmtproxy. ConnectionTcpMTProxyRandomizedIntermediate) else: client = TelegramClient(api_id, api_id, api_hash) client.start() usernames_import = [] for chat in export_chats: usernames_export = [] log.info(f"✔ [EXPORT] Parse all users from chat @{chat} ...") users = client.get_participants(chat) log.info(f"✔ [EXPORT] Users parsed: {len(users)}") log.debug(f"✔ [EXPORT] Users: \n{users}") usernames_export = filter_users(users=users, exclude_bots=exclude_bots, exclude_deleted=exclude_deleted, exclude_offline=exclude_offline_days, users_blacklist=usernames_blacklist) # Exclude chat admins if exclude_admins: usernames_admins = [] for user in client.iter_participants(chat,
class TGInformer: def __init__( self, account_id=None, db_prod_ip=None, db_prod_port=None, db_prod_name=None, db_prod_user=None, db_prod_password=None, db_local_ip=None, db_local_port=None, db_local_name=None, db_local_user=None, db_local_password=None, tg_notifications_channel_id=None, google_credentials_path=None, google_sheet_name=None, ): # ------------------ # Instance variables # ------------------ self.keyword_list = [] self.channel_list = [] self.channel_meta = {} self.bot_task = None self.KEYWORD_REFRESH_WAIT = 15 * 60 self.MIN_CHANNEL_JOIN_WAIT = 30 self.MAX_CHANNEL_JOIN_WAIT = 120 self.bot_uptime = 0 # -------------- # Display banner # -------------- print(""" ____ ____ / _/___ / __/___ _________ ___ ___ _____ / // __ \/ /_/ __ \/ ___/ __ `__ \/ _ \/ ___/ _/ // / / / __/ /_/ / / / / / / / / __/ / /___/_/ /_/_/ \____/_/ /_/ /_/ /_/\___/_/ by @paulpierre 11-26-2019 """) # ------------------------------------------------ # Check if we're in app engine and set environment # ------------------------------------------------ self.MYSQL_CONNECTOR_STRING = 'mysql+pymysql://{}:{}@{}:{}/{}'.format( db_prod_user, db_prod_password, db_prod_ip, db_prod_port, db_prod_name) '''if os.getenv('GAE_INSTANCE'): self.SERVER_MODE = 'prod' # prod vs local self.MYSQL_CONNECTOR_STRING = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(db_prod_user, db_prod_password, db_prod_ip, db_prod_port, db_prod_name) else: self.SERVER_MODE = 'local' self.MYSQL_CONNECTOR_STRING = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(db_local_user, db_local_password, db_local_ip, db_local_port, db_local_name) logging.info('SERVER_MODE: {} GAE_ENV: {}'.format(self.SERVER_MODE, str(os.getenv('GAE_INSTANCE'))))''' # ----------------------------------------- # Set the channel we want to send alerts to # ----------------------------------------- self.monitor_channel = tg_notifications_channel_id if not account_id: logging.error('Must specify account_id for bot instance') return # ----------------------- # Initialize Google Sheet 谷歌表进行初始化 # ----------------------- '''scope = [ 'https://docs.google.com/spreadsheets/d/1cPLE0raSMEflvDBwENu36J1pmyd8hVKdAT6eGd9eAGQ/edit#gid=0', ] # 'https://drive.google.com/drive/my-drive' creds = ServiceAccountCredentials.from_json_keyfile_name(google_credentials_path, scope) self.gsheet = gspread.authorize(creds) self.sheet = self.gsheet.open(google_sheet_name).sheet1''' # ------------------- # Initialize database 初始化数据库 # ------------------- self.engine = db.create_engine(self.MYSQL_CONNECTOR_STRING, pool_size=50, max_overflow=100) # , echo=True self.Session = sessionmaker(bind=self.engine) self.session = self.Session() # -------------------- # Load account from DB 加载数据库里面的账户 # -------------------- self.tg_user = None try: self.account = self.session.query(Account).filter_by( account_id=account_id).first() print(self.account) except ProgrammingError as e: logging.error('Database is not set up, setting it up') build_database.initialize_db() self.account = self.session.query(Account).filter_by( account_id=account_id).first() if not self.account: logging.error( 'Invalid account_id {} for bot instance'.format(account_id)) sys.exit(0) # ---------------------- # Telegram service login # ---------------------- logging.info('Logging in with account # {}'.format( self.account.account_phone)) session_file = 'session/' + self.account.account_phone.replace('+', '') self.client = TelegramClient(session_file, self.account.account_api_id, self.account.account_api_hash) # ----------------------- # Authorize from terminal # ----------------------- # TODO: automate authcode with the Burner API self.client.connect() if not self.client.is_user_authorized(): logging.info('Client is currently not logged in, please sign in!') self.client.send_code_request(self.account.account_phone) self.tg_user = self.client.sign_in(self.account.account_phone, input('Enter code: ')) # ============= # Get all users # ============= def get_channel_all_users(self, channel_id): # TODO: this function is not complete channel = self.client.get_entity(PeerChat(channel_id)) users = self.client.get_participants(channel) print('total users: {}'.format(users.total)) for user in users: if user.username is not None and not user.is_self: print(utils.get_display_name(user), user.username, user.id, user.bot, user.verified, user.restricted, user.first_name, user.last_name, user.phone, user.is_self) # ===================== # Get # of participants # ===================== async def get_channel_user_count(self, channel): data = await self.client.get_entity(PeerChannel(-channel)) users = await self.client.get_participants(data) return users.total # ======================= # Get channel by group ID # ======================= def get_channel_info_by_group_id(self, id): channel = self.client.get_entity(PeerChat(id)) return { 'channel_id': channel.id, 'channel_title': channel.title, 'is_broadcast': False, 'is_mega_group': False, 'channel_access_hash': None, } # ========================== # Get channel by channel URL # ========================== async def get_channel_info_by_url(self, url): logging.info('{}: Getting channel info with url: {}'.format( sys._getframe().f_code.co_name, url)) channel_hash = utils.parse_username(url)[0] # ----------------------------------------- # Test if we can get entity by channel hash # ----------------------------------------- try: channel = await self.client.get_entity(channel_hash) except ValueError: logging.info('{}: Not a valid telegram URL: {}'.format( sys._getframe().f_code.co_name, url)) return False except FloodWaitError as e: logging.info('{}: Got a flood wait error for: {}'.format( sys._getframe().f_code.co_name, url)) await asyncio.sleep(e.seconds * 2) return { 'channel_id': channel.id, 'channel_title': channel.title, 'is_broadcast': channel.broadcast, 'is_mega_group': channel.megagroup, 'channel_access_hash': channel.access_hash, } # =================== # Get user info by ID # =================== async def get_user_by_id(self, user_id=None): u = await self.client.get_input_entity(PeerUser(user_id=user_id)) user = await self.client(GetFullUserRequest(u)) logging.info('{}: User ID {} has data:\n {}\n\n'.format( sys._getframe().f_code.co_name, user_id, user)) return { 'username': user.user.username, 'first_name': user.user.first_name, 'last_name': user.user.last_name, 'is_verified': user.user.verified, 'is_bot': user.user.bot, 'is_restricted': user.user.restricted, 'phone': user.user.phone, } # ============================== # Initialize keywords to monitor # ============================== def init_keywords(self): keywords = self.session.query(Keyword).filter_by( keyword_is_enabled=True).all() for keyword in keywords: self.keyword_list.append({ 'id': keyword.keyword_id, 'name': keyword.keyword_description, 'regex': keyword.keyword_regex }) logging.info('{}: Monitoring keywords: {}'.format( sys._getframe().f_code.co_name, json.dumps(self.keyword_list, indent=4))) # =========================== # Initialize channels to join # =========================== async def init_monitor_channels(self): # --------------------- # Let's start listening # --------------------- @self.client.on(events.NewMessage) async def message_event_handler(event): await self.filter_message(event) # ----------------------------- # Update the channel data in DB 更新数据库中的通道数据 # ----------------------------- current_channels = [] # Lets iterate through all the open chat channels we have 让我们遍历所有开放的聊天频道 async for dialog in self.client.iter_dialogs(): channel_id = dialog.id # [informer.py -> 271] # As long as it is not a chat with ourselves 只要不是和自己聊天 if not dialog.is_user: # Certain channels have a prefix of 100, lets remove that 某些频道有一个100的前缀,让我们删除它 if str(abs(channel_id))[:3] == '100': channel_id = int(str(abs(channel_id))[3:]) # Lets add it to the current list of channels we're in # 让我们把它添加到当前的频道列表中 current_channels.append(channel_id) logging.info('id: {} name: {}'.format(dialog.id, dialog.name)) logging.info('{}: ### Current channels {}'.format( sys._getframe().f_code.co_name, json.dumps(current_channels))) # ----------------------------------- # Get the list of channels to monitor 获取要监视的通道列表 # ----------------------------------- self.session = self.Session() account = self.session.query(Account).first() monitors = self.session.query(Monitor).filter_by( account_id=account.account_id).all() channels_to_monitor = [] for monitor in monitors: channel_data = { 'channel_id': monitor.channel.channel_id, 'channel_name': monitor.channel.channel_name, 'channel_title': monitor.channel.channel_title, 'channel_url': monitor.channel.channel_url, 'account_id': monitor.channel.account_id, 'channel_is_megagroup': monitor.channel.channel_is_mega_group, 'channel_is_group': monitor.channel.channel_is_group, 'channel_is_private': monitor.channel.channel_is_private, 'channel_is_broadcast': monitor.channel.channel_is_broadcast, 'channel_access_hash': monitor.channel.channel_access_hash, 'channel_size': monitor.channel.channel_size, 'channel_is_enabled': monitor.channel.channel_is_enabled, 'channel_tcreate': monitor.channel.channel_tcreate } if monitor.channel.channel_is_enabled is True: channels_to_monitor.append(channel_data) self.session.close() # ------------------------------- # Iterate through channel objects # ------------------------------- for channel in channels_to_monitor: self.session = self.Session() channel_obj = self.session.query(Channel).filter_by( channel_id=channel['channel_id']).first() # ------------------------------- # We have sufficient channel data # ------------------------------- if channel['channel_id']: self.channel_list.append(channel['channel_id']) logging.info( 'Adding channel {} to monitoring w/ ID: {} hash: {}'. format(channel['channel_name'], channel['channel_id'], channel['channel_access_hash'])) self.channel_meta[channel['channel_id']] = { 'channel_id': channel['channel_id'], 'channel_title': channel['channel_title'], 'channel_url': channel['channel_url'], 'channel_size': 0, 'channel_texpire': datetime.now() + timedelta(hours=3) } else: # ------------------------ # If not grab channel data # ------------------------ if channel['channel_url'] and '/joinchat/' not in channel[ 'channel_url']: o = await self.get_channel_info_by_url( channel['channel_url']) # ----------------------------- # If channel is invalid, ignore # ----------------------------- if o is False: logging.error('Invalid channel URL: {}'.format( channel['channel_url'])) continue logging.info('{}: ### Successfully identified {}'.format( sys._getframe().f_code.co_name, channel['channel_name'])) # ------------------------- # If the channel is a group # ------------------------- elif channel['channel_is_group']: o = await self.get_channel_info_by_group_id( channel['channel_id']) logging.info('{}: ### Successfully identified {}'.format( sys._getframe().f_code.co_name, channel['channel_name'])) else: logging.info('{}: Unable to indentify channel {}'.format( sys._getframe().f_code.co_name, channel['channel_name'])) continue channel_obj.channel_id = o['channel_id'] channel_obj.channel_title = o['channel_title'] channel_obj.channel_is_broadcast = o['is_broadcast'] channel_obj.channel_is_mega_group = o['is_mega_group'] channel_obj.channel_access_hash = o['channel_access_hash'] self.channel_meta[o['channel_id']] = { 'channel_id': o['channel_id'], 'channel_title': o['channel_title'], 'channel_url': channel['channel_url'], 'channel_size': 0, 'channel_texpire': datetime.now() + timedelta(hours=3) } # ------------------------------- # Determine is channel is private 确定通道是私有的 # ------------------------------- channel_is_private = True if ( channel['channel_is_private'] or '/joinchat/' in channel['channel_url']) else False if channel_is_private: logging.info( 'channel_is_private: {}'.format(channel_is_private)) # ------------------------------------------ # Join if public channel and we're not in it # ------------------------------------------ if channel[ 'channel_is_group'] is False and channel_is_private is False and channel[ 'channel_id'] not in current_channels: logging.info('{}: Joining channel: {} => {}'.format( sys._getframe().f_code.co_name, channel['channel_id'], channel['channel_name'])) try: await self.client( JoinChannelRequest(channel=await self.client. get_entity(channel['channel_url']))) sec = randrange(self.MIN_CHANNEL_JOIN_WAIT, self.MAX_CHANNEL_JOIN_WAIT) logging.info('sleeping for {} seconds'.format(sec)) await asyncio.sleep(sec) except FloodWaitError as e: logging.info( 'Received FloodWaitError, waiting for {} seconds..'. format(e.seconds)) # Lets wait twice as long as the API tells us for posterity await asyncio.sleep(e.seconds * 2) except ChannelPrivateError as e: logging.info( 'Channel is private or we were banned bc we didnt respond to bot' ) channel['channel_is_enabled'] = False # ------------------------------------------ # Join if private channel and we're not in it # ------------------------------------------ elif channel_is_private and channel[ 'channel_id'] not in current_channels: channel_obj.channel_is_private = True logging.info('{}: Joining private channel: {} => {}'.format( sys._getframe().f_code.co_name, channel['channel_id'], channel['channel_name'])) # ------------------------------------- # Join private channel with secret hash # ------------------------------------- channel_hash = channel['channel_url'].replace( 'https://t.me/joinchat/', '') try: await self.client( ImportChatInviteRequest(hash=channel_hash)) # ---------------------- # Counter FloodWaitError # ---------------------- sec = randrange(self.MIN_CHANNEL_JOIN_WAIT, self.MAX_CHANNEL_JOIN_WAIT) logging.info('sleeping for {} seconds'.format(sec)) await asyncio.sleep(sec) except FloodWaitError as e: logging.info( 'Received FloodWaitError, waiting for {} seconds..'. format(e.seconds)) await asyncio.sleep(e.seconds * 2) except ChannelPrivateError as e: logging.info( 'Channel is private or we were banned bc we didnt respond to bot' ) channel['channel_is_enabled'] = False except UserAlreadyParticipantError as e: logging.info('Already in channel, skipping') self.session.close() continue # --------------------------------- # Rollback session if we get a dupe # --------------------------------- try: self.session.commit() except IntegrityError: self.session.rollback() except InterfaceError: pass self.session.close() logging.info('{}: Monitoring channels: {}'.format( sys._getframe().f_code.co_name, json.dumps(self.channel_list, indent=4))) logging.info('Channel METADATA: {}'.format(self.channel_meta)) # =========================== # Filter the incoming message # =========================== async def filter_message(self, event): # If this is a channel, grab the channel ID if isinstance(event.message.to_id, PeerChannel): channel_id = event.message.to_id.channel_id # If this is a group chat, grab the chat ID elif isinstance(event.message.to_id, PeerChat): channel_id = event.message.chat_id else: # Message comes neither from a channel or chat, lets skip return # Channel values from the API are signed ints, lets get ABS for consistency channel_id = abs(channel_id) message = event.raw_text # Lets check to see if the message comes from our channel list if channel_id in self.channel_list: # Lets iterate through our keywords to monitor list for keyword in self.keyword_list: # If it matches the regex then voila! if re.search(keyword['regex'], message, re.IGNORECASE): logging.info( 'Filtering: {}\n\nEvent raw text: {} \n\n Data: {}'. format(channel_id, event.raw_text, event)) # Lets send the notification with all the pertinent information in the params await self.send_notification(message_obj=event.message, event=event, sender_id=event.sender_id, channel_id=channel_id, keyword=keyword['name'], keyword_id=keyword['id']) # ==================== # Handle notifications # ==================== async def send_notification(self, sender_id=None, event=None, channel_id=None, keyword=None, keyword_id=None, message_obj=None): message_text = message_obj.message # Lets set the meta data is_mention = message_obj.mentioned is_scheduled = message_obj.from_scheduled is_fwd = False if message_obj.fwd_from is None else True is_reply = False if message_obj.reply_to_msg_id is None else True is_bot = False if message_obj.via_bot_id is None else True if isinstance(message_obj.to_id, PeerChannel): is_channel = True is_group = False is_private = False elif isinstance(message_obj.to_id, PeerChat): is_channel = False is_group = True is_private = False else: is_channel = False is_group = False is_private = False # We track the channel size and set it to expire after sometime, if it does we update the participant size if channel_id in self.channel_meta and self.channel_meta[channel_id][ 'channel_size'] == 0 or datetime.now( ) > self.channel_meta[channel_id]['channel_texpire']: logging.info('refreshing the channel information') channel_size = await self.get_channel_user_count(channel_id) else: channel_size = self.channel_meta[channel_id]['channel_size'] # Lets get who sent the message sender = await event.get_sender() sender_username = sender.username channel_id = abs(channel_id) timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Set the message for the notification we're about to send in our monitor channel message = '⚠️ "{}" mentioned by {} in => "{}" url: {}\n\n Message:\n"{}\ntimestamp: {}'.format( keyword, sender_username, self.channel_meta[channel_id]['channel_title'], self.channel_meta[channel_id]['channel_url'], message_text, timestamp) logging.info('{} Sending notification {}'.format( sys._getframe().f_code.co_name, message)) # ---------------- # Send the message # ---------------- await self.client.send_message(self.monitor_channel, message) # ------------------------- # Write to the Google Sheet 写入到谷歌工作表 # ------------------------- '''self.sheet.append_row([ sender_id, sender_username, channel_id, self.channel_meta[channel_id]['channel_title'], self.channel_meta[channel_id]['channel_url'], keyword, message_text, is_mention, is_scheduled, is_fwd, is_reply, is_bot, is_channel, is_group, is_private, channel_size, timestamp ])''' # -------------- # Add user to DB # -------------- o = await self.get_user_by_id(sender_id) self.session = self.Session() if not bool( self.session.query(ChatUser).filter_by( chat_user_id=sender_id).all()): self.session.add( ChatUser(chat_user_id=sender_id, chat_user_is_bot=o['is_bot'], chat_user_is_verified=o['is_verified'], chat_user_is_restricted=o['is_restricted'], chat_user_first_name=o['first_name'], chat_user_last_name=o['last_name'], chat_user_name=o['username'], chat_user_phone=o['phone'], chat_user_tlogin=datetime.now(), chat_user_tmodified=datetime.now())) # ----------- # Add message # ----------- msg = Message(chat_user_id=sender_id, account_id=self.account.account_id, channel_id=channel_id, keyword_id=keyword_id, message_text=message_text, message_is_mention=is_mention, message_is_scheduled=is_scheduled, message_is_fwd=is_fwd, message_is_reply=is_reply, message_is_bot=is_bot, message_is_group=is_group, message_is_private=is_private, message_is_channel=is_channel, message_channel_size=channel_size, message_tcreate=datetime.now()) self.session.add(msg) self.session.flush() message_id = msg.message_id self.session.add( Notification(keyword_id=keyword_id, message_id=message_id, channel_id=channel_id, account_id=self.account.account_id, chat_user_id=sender_id)) # ----------- # Write to DB # ----------- try: self.session.commit() except IntegrityError: pass self.session.close() async def update_keyword_list(self): # ------------------------------ # Lets update keywords in memory # ------------------------------ # TODO: functionality to poll the DB for new keywords and refresh in memory logging.info('### updating keyword_list') pass # =========================== # Loop we run while we listen 边监听边循环 # =========================== async def bot_interval(self): self.init_keywords() await self.init_monitor_channels() while True: logging.info('### Running bot interval') await self.update_keyword_list() await asyncio.sleep(self.KEYWORD_REFRESH_WAIT) def stop_bot_interval(self): self.bot_task.cancel() # =========================== # Initialize connection to TG # =========================== def init(self): loop = asyncio.get_event_loop() self.bot_task = loop.create_task(self.bot_interval()) with self.client: self.client.run_until_disconnected() try: loop.run_until_complete(self.bot_task) except asyncio.CancelledError: logging.info('### Async cancelled') pass
from telethon import TelegramClient, sync api_id = 'YOUR_TELEGRAM_ID' api_hash = 'YOUR_TELEGRAM_HASH' client = TelegramClient('YOUR_PHONE_NUMBER', api_id, api_hash) client.start() with client: # Set USER_ID or GROUP_ID or CHANNEL_ID above results = client.get_participants('@username', aggressive=True) print(str(len(results)) + ' found users') users = [] for result in results: print(str(result.id) + ' - ' + result.first_name)
def scrape_task(user_id, group_id, tg_account_id=None): user = User.objects.get(pk=user_id) group = TelegramGroup.objects.get(pk=group_id) if tg_account_id: account = TelegramAccount.objects.get(pk=tg_account_id) else: try: account = random.choice( TelegramAccount.objects.filter(active=True, confirmed=True)) except IndexError: return { 'success': False, 'error': _('No available active accounts ' 'for scrapping.') } proxy_settings = (socks.HTTP, settings.PROXY_HOST, settings.PROXY_PORT, True, settings.PROXY_USERNAME + '-session-{}'.format(random.randint(9999, 9999999)), settings.PROXY_PASSWORD) account.set_is_used(True) client = TelegramClient(StringSession(account.session), account.api_id, account.api_hash, proxy=proxy_settings) client.connect() try: try: group_entity = client.get_input_entity( group.username if group.username else group.join_link) except Exception as e: logger.exception(e) account.set_is_used(False) client.disconnect() return {'success': False, 'error': _('Error finding group.')} joined = join_group(client, account, group_entity) if not joined: account.set_is_used(False) client.disconnect() return {'success': False, 'error': _('Error joining group.')} elif isinstance(joined, dict): # means there was an error account.set_is_used(False) client.disconnect() return joined try: members = client.get_participants( group_entity, aggressive=True, filter=ChannelParticipantsRecent()) admins = client.get_participants( group_entity, aggressive=True, filter=ChannelParticipantsAdmins()) members = [ m for m in members if not m.bot and # skip bots m not in admins and # skip admins m.username and # skip without usernames not m.is_self ] # skip if members is current client user except: account.set_is_used(False) client.disconnect() return { 'success': False, 'error': _('Error getting list of group ' 'members.') } client.disconnect() account.set_is_used(False) with transaction.atomic(): for i, m in enumerate(members): TelegramContact.objects.get_or_create(user=user, group=group, username=m.username, priority=i + 1) message = _('Scrapped {} users.'.format(len(members))) return {'success': True, 'error': None, 'message': message} except Exception as e: logger.exception(e) return { 'success': True, 'error': _('Error getting list of group ' 'members.') }
while True: participants = loop.run_until_complete(client(GetParticipantsRequest( channel, ChannelParticipantsSearch(''), offset, limit, hash=0 ))) if not participants.users: break all_participants.extend(participants.users) offset += len(participants.users) print('Magic Number: ', offset) return all_participants #channel = Channel(id=1330505769, title='\u2066♥️\u2069Empathogens❄️קהילת🍄אמפתוגנים', photo=ChatPhoto(photo_small=FileLocation(dc_id=4, volume_id=449011102, local_id=3795, secret=5154166241589927286), photo_big=FileLocation(dc_id=4, volume_id=449011102, local_id=3797, secret=-3469345200309841222)), date=datetime.datetime(2018, 9, 25, 13, 42, 14, tzinfo=datetime.timezone.utc), version=0) qq = get_channels() print('*******\n') print(qq) #sys.exit() r = loop.run_until_complete(client.get_participants(qq, None, aggressive=True)) db = open('users.db', 'wb+') for x in r: print(x) #pickle.dump(x, db) #db.write(x) #db.write() pickle.dump(r, db) sys.exit() ## fh = open('choiceVideo.mp4', 'rb') msg = loop.run_until_complete(client.send_file('me', fh, attributes=(DocumentAttributeVideo(0, 0, 0),))) location = 0 max = 2 for x in range(location, r.length():
from telethon import TelegramClient from telethon import events from telethon.tl.functions.channels import GetParticipantsRequest #from telethon.tl.functions.channels import AdminLogEvent from telethon.sync import TelegramClient api_id = 3409046 api_hash = '48ae9fbdf79edda291e1fa5796fc4665' #phone_number = '+528132341246' channel = '@pruebastienda' ################################################ client = TelegramClient('sessionname', api_id, api_hash) client.start() responses = client.get_participants(channel) print(responses[0].first_name) client.run_until_disconnected()
if (client.is_user_authorized() == False): phone_number = 'PHONE NUMBER' client.send_code_request(phone_number) myself = client.sign_in(phone_number, input('Enter code: ')) #client = InteractiveTelegramClient('session_id', 'phone', api_id, api_hash) dialog_count = 3 dialogs = client.get_dialogs(dialog_count) #print('total:', dialogs.total, '; have:', len(dialogs)) for dia in dialogs: print(utils.get_display_name(dia)) #print(client.get_participants(dia)) matchedchatids = re.findall( "(?<=PeerChannel\\(channel_id\\=).*?(?=\\))", str(client.get_dialogs(dialog_count) )) #"(?<=entity=Channel\\(id\\=).*?(?=,)" "(?<=title\\=').*?(?=')" for item in matchedchatids: print(item) print(client.get_entity(item)) #print(len(client.get_participants(item))) dialogs, entities = client.get_dialogs(dialog_count) for i, entity in enumerate(entities): i += 1 # 1-based index print('{}. {}. id: {}'.format(i, get_display_name(entity), entity.id)) #links = channels.get_channels() channel = client.get_entity(entity.id) #ch_full = client(GetFullChannelRequest(channel=ch)) members = client.get_participants(channel) print(len(members))
import time ## Defining the need variables api_id = '683428' # Input your api_id here api_hash = '967b28d111f82b906b6f28da1ff04411' # Input your api_hash here token = '927041875:AAHr9CfWRwJhXMArxIwwyjLL12es8DI62VI' admin = [577180091] ## Connection of all the integrated APIs bot = TelegramClient("Hack", api_id, api_hash) bot.start() name = input("Enter the link to the group here: ") channel = bot.get_entity(name) members = bot.get_participants(channel) chat = bot.get_entity("https://t.me/minershu") [ bot.send_message(chat, f"{each.username}") for each in members if each.username is not None and each.bot is False ] print("Bot running!!!") bot.run_until_disconnected() while True: pass
link = "CHAT LINK" try: client(ImportChatInviteRequest(link)) except: pass join = client.get_entity(link) print('Telethon-Users-Parse\n Created by @alowave') title = join.title runtime = int(time.time()) f = open('Users ' + title.replace('"', "'") + ' ' + time.ctime(runtime).replace(':', '.') + '.txt', 'a', encoding = 'utf-8') users = client.get_participants(join.id, aggressive=True) a = {} f.write(str(runtime) + ' - ' + title) f.write('\nПолучено ' + str(len(users)) + ' из ' + str(users.total) + ' пользователей.\n') for user in users: if user.username == None: username = '******' else: username = user.username a[user.id] = username sort_users = sorted(a) for user in sort_users: user_str = str(user) + ' : ' + a[user]
# get all the users and print them #for u in client.get_participants(dialogs[3].entity,limit=0): # print(u.id, u.first_name, u.last_name, u.username, u.access_hash) #for u in client.get_participants(channel): # print(u.id, u.first_name, u.last_name, u.username, u.access_hash) #for i in channels: # print(i) #for u in dialogs: # print(u) for u in dialogs: print(u) #for u in dialogs: # print(u.name) #print(dialogs[3]) #print(client.get_participants(dialogs[3].entity,limit=0).total) print(dialogs[groupname]) for u in client.get_participants(dialogs[groupname], aggressive=True): print(u.username, u.first_name, u.last_name, u.username, u.id, u.access_hash) receiver = InputPeerUser(u.id, u.access_hash) # sending message using telegram client client.send_message(receiver, message, parse_mode='html')
def process_telegram_list(): ####################### url_list2 = [] try: conn = mysql.connector.connect(host='***m', user='******', passwd='***', db='***') except: print('aaaa') sys.exit() cursor = conn.cursor() # SQL 查询语句 search_sql = 'select * from h_hot' try: # 执行SQL语句 cursor.execute(search_sql) # 获取所有记录列表 results = cursor.fetchall() for row in results: if row[2] != None and row[2] != '': token_cid = row[1] token_url = row[2] # 打印结果 #print(token_id, token_name, token_symbol, token_github_master) url_list2.append([token_cid, token_url]) except: print("Error: unable to fecth data") # 关闭数据库连接 cursor.close() conn.close() ################ url_list_mysql = [] today = str(datetime.date.today().strftime('%Y%m%d')) count = 0 api_id = 123456 # 用户api_id api_hash = '***' # 用户 api_hash phone_number = '+123456' # 用户号码 # client = TelegramClient('session_id', # api_id=api_id, api_hash=api_hash, # # proxy=(socks.SOCKS5, 'localhost', 61800) # proxy=(socks.SOCKS5, 'localhost', 61800) # ) client = TelegramClient('session_id', api_id, api_hash) client.session.report_errors = False client.start() client.connect() for i in range(len(url_list2)): #for i in range(3): try: channel_str = url_list2[i][1] if 'https://t.me/' in channel_str and 'join' not in channel_str: channel = client.get_entity( channel_str) # 'https://t.me/StratisPlatform' print(i, len(url_list2), url_list2[i][1]) participants = client.get_participants(channel) cangku2 = {} cangku2['personNum'] = str(len(participants)) cangku2['updateTime'] = today cangku2['cid'] = str(url_list2[i][0]) cangku2['telegramUrl'] = str(url_list2[i][1]) url_list_mysql.append(cangku2) count = count + 1 except: print('error!', url_list2[i]) print(str(count) + '个数据爬取完成') return url_list_mysql, count
} list_channel = [] list_user = {} for d in client.get_dialogs(): if d.is_channel: # remove - 100 in front of channel id sent back by API. CHANNEL_ID = int(str(d.id)[4:]) if CHANNEL_ID not in LIST_CHANNEL_ID: continue list_channel.append(d) # get all the users for p in client.get_participants(d): if p.id not in list_user: try: was_online = p.status.was_online except AttributeError: was_online = datetime.datetime.now() first_name = p.first_name or '' last_name = p.last_name or '' username = p.username or '' list_user[p.id] = { 'first_name': first_name, 'last_name': last_name, 'username': username, 'id': p.id, 'was_online': was_online,
from telethon import TelegramClient, sync from dotenv import load_dotenv import os import sys scripts_path = os.path.dirname(os.path.abspath(__file__)) project_root = os.path.join(scripts_path, '..') sys.path.insert(0, project_root) from config.provider import TelegramConfig load_dotenv() channel_id = input('Please enter channel ID: ') telegram_config = TelegramConfig() telegram_client = TelegramClient(telegram_config.telegram_api_session_name, telegram_config.telegram_api_id, telegram_config.telegram_api_hash).start() participants = telegram_client.get_participants(int(channel_id)) details = [{"username": o.username, "id": o.id} for o in participants] for d in details: print(d)
import sys from telethon.tl.types import PeerUser, PeerChat, PeerChannel if __name__ == '__main__': api_id = * api_hash = '*' client = TelegramClient('session_name', api_id, api_hash) client.start() """ my_name = utils.get_display_name(client.get_me()) msg = 'test' id_client = 1220038 id_client1 = client.get_entity(386520922) client.send_message(id_client1, msg) """ users = client.get_participants('t.me/joinchat/*') print(users[0],'\n') print(users[1],'\n') print(users[2],'\n') """ for user in users: if user.username is not None: print(user.username,user.first_name,'\n') """ my_name = utils.get_display_name(client.get_me()) msg = 'test' id_client = 386520922 client.send_message(id_client, msg)
def result(): if request.method == 'POST': try: apikey = request.form.get('apikey') inputdict['apikey'] = apikey accesshash = request.form.get('accesshash') inputdict['accesshash'] = accesshash phonenumber = request.form.get('phonenumber') inputdict['phonenumber'] = phonenumber channelname = request.form.get('channelname') client = TelegramClient(phonenumber, apikey, accesshash) client.session.report_errors = False client.connect() if 'file' not in request.files: print("No file to upload") if not client.is_user_authorized(): #client.send_code_request(phonenumber) #client.sign_in(phonenumber, input('Enter the code: ')) client.send_code_request(phonenumber) print("sent code") return render_template("codeinput.html") channel_entity = client.get_entity(channelname) members = client.get_participants(channel_entity) printmemberattr(members) print(members) for member in members: listtoexportcsv.append( [member.id, member.username, member.phone]) return render_template("result.html", members=members) else: print("upload file users and add to telegram channel") channeltoadd = request.form.get('channeltoadd') inputdict['channeltoadd'] = channeltoadd if channeltoadd == "": print("không nhập thông tin channel") return render_template("error.html") else: print("start to get file name") file = request.files['file'] filename = secure_filename(file.filename) print(filename) # os.path.join is used so that paths work in every operating system file.save(os.path.join("/root/nammuoi", filename)) with open("/root/nammuoi/" + filename) as f: for line in f: file_content.append(line) if not client.is_user_authorized(): client.send_code_request(phonenumber) print("sent code to phone") return render_template("adduserscodeinput.html") # You should use os.path.join here too. try: _thread.start_new_thread( addUserFromFileToChannel, (file_content, client, channeltoadd)) except: print("Error: unable to start thread") return render_template("success.html") except Exception as e: print(e) return render_template("error.html")
#dialogs = client.get_dialogs() dialogs = {d.name: d.entity for d in client.get_dialogs()} # get all the users and print them #for u in client.get_participants(dialogs[3].entity,limit=0): # print(u.id, u.first_name, u.last_name, u.username, u.access_hash) #for u in client.get_participants(channel): # print(u.id, u.first_name, u.last_name, u.username, u.access_hash) #for i in channels: # print(i) #for u in dialogs: # print(u) for u in dialogs: print(u) #for u in dialogs: # print(u.name) #print(dialogs[3]) #for u in client.get_participants(dialogs[3].entity,aggressive=True): # print(u.username, u.first_name, u.last_name, u.username, u.id, u.access_hash) print(client.get_participants(dialogs[groupname], limit=0).total) #print(dialogs['Comando e Controle']) print(dialogs[groupname]) client.disconnect()
# with TelegramClient('anon', api_id, api_hash) as client: # class telegram_client: # def __init__(self, id, username, fname, lname, phone, status): # self.id = id # self.username = username # self.fname = fname # self.lname = lname # self.phone = phone # self.status = status client = TelegramClient('anon', api_id, api_hash).start() add = [] # participants = client.get_participants('DbFirReRnqxjYpQlwJRQuw') users = client.get_participants('AudiosdeMarcuxx') # print(len(users)) # t1 = telegram_client(users[0].id, users[0].username, users[0].first_name, users[0].last_name, users[0].phone, 0) # t1 = (users[0].id, users[0].username, users[0].first_name, users[0].last_name, users[0].phone, 0) # print(t1) # add.append(t1) # print(add[0].__dict__) # t2 = (users[1].id, users[1].username, users[1].first_name, users[1].last_name, users[1].phone, 0) # add.append(t2) # print(add) ###for u in users: # t = (str(u.id), u.username, u.first_name, u.last_name, u.phone, 0, ) # add.append(t) # db.insertGroup(add) # print(add)