def find_user_by_keywords(self, *keywords, max_users=10):
'''
Cerca dei profili Twitter compatibili con le parole chiave specificate.
Params:
@keywords: Parole chiave da utilizzare per la ricerca
@max_users [5]: Massimo numero di utenti da ricercare
Return:
Lista di profili Twitter (profiles.twitter_profile)
'''
# Variabili locali
usernames = []
tw_profiles = []
if not self.is_initialized:
ex = exceptions.WebDriverNotInitialized(
'The WebDriver is not initialized, please call the init() function'
)
self._manage_error(WEBDRIVER_NOT_INITIALIZED, ex)
return None
# Compone l'URL da utilizzare per la ricerca
keys = [str(s).strip() for s in keywords if s is not None]
search_string = ' '.join(keys)
if search_string == '':
return []
self._driver.get(SEARCH_PEOPLE_URL.format(search_string))
# Ricerca gli username degli utenti individuati
usernames_elms = self._driver.find_elements(By.XPATH,
RESULTS_USERNAMES_XPATH)
# Ottiene i link degli utenti
usernames = [elm.text for elm in usernames_elms]
# Limita il massimo numero di profili da cercare
if len(usernames) > max_users:
usernames = usernames[:max_users]
# Ottiene i dati dei profili
for username in usernames:
p = self.find_user_by_username(username)
tw_profiles.append(p)
if self._logger is not None:
self._logger.info('Found {} profiles with the keywords: {}'.format(
len(tw_profiles), generic.only_ASCII(','.join(keys))))
return tw_profiles
def download_profile_images(self, tw_profile, save_dir, max_photo=30):
'''
Scarica le immagini del profilo utente.
Params:
@tw_profile: Profilo Twitter (profiles.twitter_profile) di cui scaricare le immagini
@save_dir: Directory di salvataggio delle immagini
@max_photo [30]: Massimo numero di foto da scaricare
'''
# Variabili locali
url_images = []
if not self.is_initialized:
ex = exceptions.WebDriverNotInitialized(
'The WebDriver is not initialized, please call the init() function'
)
self._manage_error(WEBDRIVER_NOT_INITIALIZED, ex)
return False
# Naviga sull'immagine profilo
self._driver.get(PROFILE_URL.format(tw_profile.username))
# Crea la cartella se serve
if not os.path.exists(save_dir):
os.makedirs(save_dir)
# Ottiene i link alle immagini
url_images_elms = self._driver.find_elements(By.XPATH,
LAST_PHOTOS_XPATH)
url_images = [elm.get_attribute('src') for elm in url_images_elms]
# Limita il numero di foto da scaricare
if len(url_images) > max_photo:
url_images = url_images[:max_photo]
# Scarica le immagini con il formato 'nomeutente_index.jpg'
index = 0
for url in url_images:
abs_dir = os.path.abspath(save_dir)
save_path = os.path.join(
abs_dir, '{}_{}.jpg'.format(tw_profile.username, index))
self._image_download(url, save_path)
index += 1
return True
def download_profile_photo(self, tw_profile, save_path):
'''
Scarica l'immagine profilo dell'utente specificato.
Params:
@tw_profile: Profilo Twitter (profiles.twitter_profile) di cui scaricare l'immagine profilo
@save_path: Percorso di salvataggio dell'immagine
Return:
True se l'immagine è stata scaricata, False altrimenti
'''
if not self.is_initialized:
ex = exceptions.WebDriverNotInitialized(
'The WebDriver is not initialized, please call the init() function'
)
self._manage_error(WEBDRIVER_NOT_INITIALIZED, ex)
return False
# Naviga sull'immagine profilo
self._driver.get(PROFILE_PHOTO_URL.format(tw_profile.username))
# Ottiene l'immagine profilo
try:
wait = WebDriverWait(self._driver, self._timeout)
profile_image = wait.until(
EC.presence_of_element_located(
(By.XPATH, PROFILE_PHOTO_XPATH)))
except TimeoutException:
ex = exceptions.NoProfilePhoto(
'The user does not have a profile photo')
self._manage_error(NO_PROFILE_PHOTO, ex)
return False
except Exception as ex:
self._manage_error(WEBDRIVER_GENERIC_ERROR, ex)
return False
# Ottiene l'URL dell'immagine
url = profile_image.get_attribute('src')
# Scarica l'immagine
return self._image_download(url, save_path)
def fb_login(self, fb_mail, fb_password):
'''
Esegue il login a Facebook. Il WebDriver dev'essere inizializzato.
Params:
@fb_mail: Email dell'account Facebook
@fb_password: Password dell'account Facebook
Return:
True se è stato effettuato correttamente il login, False altrimenti (o se il WebDriver non è stato inizializzato)
'''
# Se il driver non è inizializzato esce
if not self.is_initialized:
ex = exceptions.WebDriverNotInitialized('The WebDriver is not initialized, please call the init_scraper() function')
self._manage_error(WEBDRIVER_NOT_INITIALIZED, ex)
return False
# Naviga sulla pagina di login
self._driver.get(BASE_URL)
time.sleep(SLEEP_TIME_MEDIUM)
self._request_manager()
# Cerca gli elementi per fare il login
wait = WebDriverWait(self._driver, self._timeout)
try:
login_button = wait.until(
EC.element_to_be_clickable((By.ID, LOGIN_BUTTON_ID)))
email_field = wait.until(
EC.presence_of_element_located((By.ID, LOGIN_MAIL_ID)))
password_field = wait.until(
EC.presence_of_element_located((By.ID, LOGIN_PSW_ID)))
except TimeoutException as ex:
self._manage_error(LOGIN_CANNOT_LOAD, ex)
return False
# Inserisce i dati
email_field.send_keys(fb_mail)
password_field.send_keys(fb_password)
# Effettua il login (pulsante INVIO)
login_button.send_keys(Keys.ENTER)
# Attende che l'elemento sia visibile. Se lo è il login è corretto
try:
wait.until(
EC.element_to_be_clickable(
(By.CLASS_NAME, FB_HOME_BUTTON_CLASSNAME)))
self.is_logged = True
if self._logger is not None:
self._logger.info(
'Login successfully with user {}'.format(fb_mail))
self._request_manager()
return True
except TimeoutException as ex:
if _wait_for_correct_current_url(
self._driver, ERROR_LOGIN_URL) is True:
self._manage_error(LOGIN_INCORRECT_CREDENTIALS, ex)
else:
self._manage_error(LOGIN_GENERIC_ERROR, ex)
return False