def select_telegram_group(): ''' ''' # Collega il client Telegram with tg_functions.connect_telegram_client( password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client: # Ottiene tutte le conversazioni a cui il profilo è connesso list_conversations = tg_functions.get_all_conversations( tg_client, only_groups=True) # Menu di selezione del gruppo da analizzare print(colored('[TELEGRAM]', 'cyan') + ' Selezione gruppo da analizzare:') i = 0 for conv in list_conversations: conv_name = generic.only_ASCII(conv[0].title).strip() print( colored('[', 'red') + str(i) + colored(']', 'red') + ' {}'.format(conv_name)) i += 1 # Lascia selezionare all'utente il gruppo da analizzare print(colored('[TELEGRAM]', 'cyan') + ' Inserisci il numero del gruppo da analizzare: ', end='') # Senza ritorno a capo per mettere l'imput sulla stessa riga conv_index = input() # I colori ANSI non funzionano con input() target_group = list_conversations[int(conv_index)] group_name = generic.only_ASCII(target_group[0].title).strip() print( colored('[TELEGRAM]', 'cyan') + ' E\' stato selezionato il gruppo: {}'.format(group_name)) return target_group
def get_most_active_users(tg_group, n_active_users=25, message_limit=3000): ''' Dato un gruppo Telegram ottiene gli utenti che scrivono più messaggi Params: @tg_group: Gruppo da analizzare @n_active_users [25]: Numero massimo di utenti più attivi da individuare @message_limit[3000]: Numero massimo di messaggi da controllare per i dentificare i profili attivi ''' # Variabili locali active_users = {} with tg_functions.connect_telegram_client( password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client: # Itera i messaggi della chat dal più nuovo al più vecchio for message in tqdm( tg_client.iter_messages(tg_group, limit=message_limit)): # Ottiene l'ID dell'utente che ha scritto il messaggio user_id = message.sender_id # Prende il numero di messaggi scritti dall'utente e lo incrementa count_messages = active_users.get(user_id, 0) count_messages += 1 # Salva il numero di messaggi scritti dall'utente (se l'utente non # esiste lo crea) active_users[user_id] = count_messages # Ordina il dizionario in base al numero di messaggi scritti active_users = dict( sorted(active_users.items(), key=lambda item: item[1], reverse=True)) n_items = take(n_active_users, active_users.items()) return n_items
def download_profile_photos(self, save_dir, tg_client=None): ''' Salva le immagini profilo dell'utente (se presenti) Params: @save_dir: Cartella di salvataggio delle immagini @tg_client [None]: Client Telegram da usare Return: False se non è ancora stato associato un utente Telegram True se l'operazione va a buon fine ''' if self._tg_profile is None: if self.user_id is None: return False self.get_profile_from_userid(self.user_id, tg_client) # Crea la cartella se non esiste save_dir = os.path.abspath(save_dir) if not os.path.exists(save_dir): os.makedirs(save_dir) if tg_client is None: with tg_functions.connect_telegram_client( password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client_internal: tg_functions.download_users_profile_photos( tg_client_internal, self._tg_profile, save_dir) else: tg_functions.download_users_profile_photos(tg_client, self._tg_profile, save_dir) return True
def get_profile_from_username(self, username, tg_client=None): ''' Ottiene i dati di un profilo Telegram a partire dal suo nome utente Params: @username: Username dell'utente Telegram @tg_client [None]: Client Telegram da usare Return: False se il nome utente non esiste True se l'operazione va a buon fine ''' # Cerca il profilo su Telegram if tg_client is None: with tg_functions.connect_telegram_client( password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client_internal: profile = tg_functions.get_profiles(tg_client_internal, username) else: profile = tg_functions.get_profiles(tg_client, username) if profile is None: return False # Se non esiste il profilo corrispondente ai dati indicati ritorna False self.get_profile_from_tg_profile(profile) return True
def _select_telegram_group(): ''' Elenca tutti i gruppi a cui l'utente sta partecipando e gli permette di selezionarne uno Return: Gruppo selezionato (Telethon entity) o None se si vuole riprendere una sessione precedente ''' # Collega il client Telegram with tg_functions.connect_telegram_client(password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client: # Ottiene tutte le conversazioni a cui il profilo è connesso list_conversations = tg_functions.get_all_conversations( tg_client, only_groups=True) # Menu di selezione del gruppo da analizzare print(colored('[TELEGRAM]', 'cyan') + ' Selection of Telegram group to analyze:') i = 0 for conv in list_conversations: conv_name = generic.only_ASCII(conv[0].title).strip() print( colored( '[', 'red') + str(i) + colored( ']', 'red') + ' {}'.format(conv_name)) i += 1 # Lascia selezionare all'utente il gruppo da analizzare print( colored( '[TELEGRAM]', 'cyan') + ' Enter the index of the group to be analyzed: ', end='') # Senza ritorno a capo per mettere l'imput sulla stessa riga conv_index = input() # I colori ANSI non funzionano con input() target_group = list_conversations[int(conv_index - 1)][0] group_name = generic.only_ASCII(target_group.title).strip() print(colored('[TELEGRAM]', 'cyan') + ' Selected Telegram group: {}'.format(group_name)) _scrape_logger.info('Selected Telegram group: {}'.format(group_name)) return target_group
def _scrape_telegram(people, save_people_dir, image_dir): ''' Scarica le foto profilo degli utenti Telegram Params: @people: Profili (classes.person) di cui completare il profilo Telegram scaricandone le immagini @save_people_dir: Directory dove salvare le informazioni dei profili @image_dir: Directory dove salvare le cartelle contenenti le immagini profilo ''' # Variabili locali tg_profiles_list = [] # Ottiene ed elabora le immagini dei profili Telegram _scrape_logger.info('Download Telegram profile pictures') # Elabora solo i profili non ancora elaborati for p in people: ps = p.get_profiles('Telegram') for tg_profile in ps: if not tg_profile.is_elaborated: tg_profiles_list.append(tg_profile) # Se non ci sono profili ritorna evitando di creare un instanta Telethon if len(tg_profiles_list) <= 0: return # Scarica le immagini with tg_functions.connect_telegram_client(password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client: for p in tqdm(profiles, colored('[TELEGRAM]', 'cyan') + ' Download and image processing of Telegram profiles images'): # Se richiesto dall'utente esce dal ciclo (per chiudere il client Telegram aperto con with) # e poi termina il programma if _terminate_program: break ps = p.get_profiles('Telegram') if len(ps) == 0: continue tg_profile = ps[0] # L'unico profilo disponibile if tg_profile.is_elaborated: continue _scrape_logger.debug('Elaborating Telegram profile with username {} (ID {})'.format(tg_profile.username, tg_profile.user_id)) # Forma i percorsi images_path = os.path.join(image_dir, 'person_{}_images'.format(str(p.id))) save_path = os.path.join(save_people_dir, '{}.person'.format(p.id)) # Crea la cartella che conterrà le immagini if not os.path.exists(images_path): os.makedirs(images_path) # Scarica ed elabora le immagini tg_profile.download_profile_photos(images_path, tg_client) tg_profile.elaborate_images(images_path, tg_client) # Salva i dati pickle.dump(p, open(save_path, 'wb'), protocol=pickle.HIGHEST_PROTOCOL) database.set_person_checked(_db_path, p.id, 'Telegram') if _terminate_program: _end_program()
def _select_and_save_group_members(target_group, save_dir, aquired_profiles=None): ''' Data una directory converte i partecipanti in un oggetto 'person' Params: @target_group: Gruppo da cui ottenere i partecipanti @save_dir: Directory di salvataggio dei file utente @aquired_profiles [None]: Lista di profili già configurati. Se specificata, viene ritornata una lista di profili comprendente quelli passati per parametro e i nuovi utenti presenti nel gruppo Return: Lista di profili (person) ''' # Variabili locali profiles_list = [] # Collega il client Telegram _scrape_logger.info('Group member acquisition...') print(colored('[TELEGRAM]', 'cyan') + ' Group member acquisition...') with tg_functions.connect_telegram_client(password_manager.tg_phone, password_manager.tg_api_id, password_manager.tg_api_hash) as tg_client: tg_group_members = tg_functions.get_group_channel_members( tg_client, target_group) # --> Perchè [0]? print(colored('[TELEGRAM]', 'cyan') + ' Identified {} participants'.format(len(tg_group_members))) _scrape_logger.info( 'Identified {} participants'.format( len(tg_group_members))) # Converte i profili da Telethon a profili Telegram # interni all'applicazione, poi li aggiunge ad una # entità 'person' e li salva su disco index = 0 # Ottiene solo i nuovi profili aggiunti al gruppo if aquired_profiles is not None: # Ordina i profili per ottenere l'ID maggiore (+ 1 per poterlo poi # usare) index = max(profile.id for profile in aquired_profiles) + 1 # Filtra i profili per ID tg_saved_members_ids = [p.get_profiles( 'Telegram')[0].user_id for p in aquired_profiles] tg_group_members = [ tg_member for tg_member in tg_group_members if tg_member.id not in tg_saved_members_ids] print(colored('[TELEGRAM]', 'cyan') + ' {} new participants identified'.format(len(tg_group_members))) _scrape_logger.info('Saving profiles (Telegram) ...') for tg_profile in tqdm(tg_group_members, colored( '[TELEGRAM]', 'cyan') + ' Saving Telegram profiles'): # Crea il profilo interno Telegram tgp = profiles.telegram_profile() tgp.get_profile_from_tg_profile(tg_profile) # Lo aggiunge ad una entità persona save_path = os.path.join(save_dir, '{}.person'.format(index)) p = person.person(index) p.add_profile(tgp) pickle.dump(p, open(save_path, 'wb'), protocol=pickle.HIGHEST_PROTOCOL) profiles_list.append(p) index += 1 if _terminate_program: _end_program() profiles_list.extend(aquired_profiles) return profiles_list