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