def __init__(self, url, layout_type):
self.url = url
self.layout_type = layout_type
binary = FirefoxBinary(
'/Applications/Firefox.app/Contents/MacOS/firefox')
binary.add_command_line_options('-headless')
self.driver = webdriver.Firefox(firefox_binary=binary)
def __init__(self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
**kwargs):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override',
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": '1'})
binary = FirefoxBinary()
binary.add_command_line_options('-headless')
kwargs['firefox_binary'] = binary
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
timeout=timeout,
**kwargs)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self, maquine: Maquine, headless=True, firefox_path='firefox'):
self._maquine = maquine
try:
if headless:
os.environ['MOZ_HEADLESS'] = '1'
binary = FirefoxBinary(firefox_path, log_file=sys.stdout)
binary.add_command_line_options('--headless')
self._driver = webdriver.Firefox(firefox_binary=binary)
else:
self._driver = webdriver.Firefox()
self._requests = requests
self._is_login = False
except SessionNotCreatedException as ex:
raise ZklibWebFirefoxNotFoundException(ex.msg)
def __init__(self, profile=None, extensions=None, user_agent=None,
profile_preferences=None, fullscreen=False, wait_time=2,
timeout=90, capabilities=None, headless=False, **kwargs):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
if 'accepted_languages' in kwargs:
firefox_profile.set_preference('intl.accept_languages', kwargs['accepted_languages'])
del kwargs['accepted_languages']
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference(
'general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": '1'})
binary = FirefoxBinary()
binary.add_command_line_options('-headless')
kwargs['firefox_binary'] = binary
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
timeout=timeout, **kwargs)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def takeimage(itemID):
#setup browser for running in background
os.environ['MOZ_HEADLESS'] = '1'
binary = FirefoxBinary(FIREFOX_PATH, log_file=sys.stdout)
binary.add_command_line_options('-headless')
browser = webdriver.Firefox(executable_path=GECKODRIVER_PATH,firefox_binary=binary)
#request item url
browser.get(dbUrl + itemID)
try:
browser.find_element_by_class_name('tooltip').screenshot(cachefolder + str(itemID) + '.png')
print('Tooltip for item id : %s found at %s\nSaved at %s' % (itemID, str(dbUrl + str(itemID)), str(cachefolder+ str(itemID) + '.png')))
except:
print('Tooltip for item id : %s not found at %s' % (itemID, str(dbUrl + str(itemID))))
browser.close()
async def process(self, body):
logging.info('Web screenshot plugin process called')
# Old method
#driver = webdriver.PhantomJS()
# New with headless ff
# https://intoli.com/blog/running-selenium-with-headless-firefox/
os.environ['MOZ_HEADLESS'] = '1'
binary = FirefoxBinary('/usr/bin/firefox', log_file=sys.stdout)
binary.add_command_line_options('-headless')
driver = webdriver.Firefox(
firefox_binary=binary
)
driver.set_window_size(body.get('width', 1024), body.get('height', 768))
driver.get(body['page'])
try:
WebDriverWait(driver, body['wait']).until(
EC.presence_of_element_located((By.XPATH, body.get('xpath', '/html')))
)
except Exception as e:
logging.error(e)
logging.error("Couldn't wait for element")
screen = driver.get_screenshot_as_base64()
# .close() with headless leaves geckodriver
driver.quit()
logging.debug('Processing finished')
return {
"head": '### {} <a href="{}">clickable</a>'.format(body['page'], body['page']),
"body": '<img src="data:image/png;base64, {}" alt="Screenshot" />'.format(screen)
}
cv2.imwrite('./output/pictorial/' + str(num) + '-' + title + '.png',
screenshot) #Save
elif (image_ratio < (THRESHOLD_TEXT * 100)):
cv2.imwrite('./output/text/' + str(num) + '-' + title + '.png',
screenshot) #Save
else:
cv2.imwrite('./output/mixed/' + str(num) + '-' + title + '.png',
screenshot) #Save
# main
if __name__ == '__main__':
# csvの読み込み
tag_list_num = count_row_csv(CSV_INPUT_PATH)
csv_web_list = pd.read_csv(CSV_INPUT_PATH)
print('行数: ' + str(tag_list_num))
binary = FirefoxBinary('/Applications/Firefox.app/Contents/MacOS/firefox')
binary.add_command_line_options('-headless')
driver = webdriver.Firefox(firefox_binary=binary)
driver.set_window_size(SCREEN_W, SCREEN_H)
for i in range(tag_list_num):
print('解析対象' + str(i + 1) + ': ' + str(csv_web_list.iat[i, 2]))
analyze_page(driver, i + 1, csv_web_list.iat[i, 1],
csv_web_list.iat[i, 2])
# Close Web Browser
driver.quit()
def __init__(self):
os.environ["MOZ_HEADLESS"] = "1"
binary = FirefoxBinary()
binary.add_command_line_options("-headless")
super(Render, self).__init__(firefox_binary=binary)
class ProxiedBrowser(object):
def __init__(self, dir, tor_port=9150):
self.dir = dir
self.tor_port = int(tor_port)
def open(self):
cap_dir = join(self.dir, "caps")
try:
os.makedirs(cap_dir)
except:
pass
self.proxy = TCP(cap_dir=cap_dir, tor_port=self.tor_port)
self.proxy.start()
while not self.proxy.running:
logger.info("Waiting for proxy to start...")
sleep(1)
logger.info("Starting Xvfb virtual display")
self.vdisplay = Xvfb(width=1280, height=740)
self.vdisplay.start()
logger.info("Webdriver starting..")
self.binary = FirefoxBinary(firefox_path=join(self.dir, FIREFOX_PATH),
log_file=open("firefox.log", "w"))
self.binary.add_command_line_options("--verbose")
self.profile = FirefoxProfile(
profile_directory=join(self.dir, FIREFOX_PROFILE))
self.profile.set_preference("network.proxy.socks_port",
self.proxy.port)
self.profile.set_preference("extensions.torlauncher.start_tor",
False) # We started tor manually earlier.
self.profile.set_preference("browser.startup.homepage", "")
self.profile.set_preference("browser.startup.page", 0)
self.profile.update_preferences()
try:
self.driver = webdriver.Firefox(firefox_binary=self.binary,
firefox_profile=self.profile)
sleep(2) # hack: wait until homepage etc have loaded.
except Exception as ex:
self.proxy.close()
raise ex
return self
def __enter__(self):
return self.open()
def get(self, url):
print("Fetching {url}".format(url=url))
self.proxy.consume_results(
) # clear anything previous, e.g the browsers homepage, whatever update checkers etc.
self.driver.get(url)
capture_files = self.proxy.consume_results()
responses = list()
for capture_file in capture_files:
responses += extract_from_capturefile(capture_file)
os.remove(capture_file)
return responses
def close(self):
logging.info("Closing webdriver")
self.driver.quit()
logging.info("Closing virtual display")
self.vdisplay.stop()
logging.info("Closing proxy")
self.proxy.close()
self.proxy.join()
def __exit__(self, type, value, traceback):
self.close()
def main():
xvfbCmdLine = "/usr/bin/Xvfb :11 -nolisten tcp -ac -cc 4 -screen 0 1200x800x24"
xvfbProcess = Popen(xvfbCmdLine, shell=True, stderr=STDOUT)
binary = FirefoxBinary(firefox_path="../Personalized-Reco/firefox/firefox")
binary.add_command_line_options('--display=:11.0')
driver = webdriver.Firefox(firefox_binary=binary)
driver.set_window_size(1200, 800) # optional
for single_date in daterange(start_date, end_date):
try:
if single_date.month == 1:
url = "http://www.theguardian.com/theguardian/{0}/jan/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 2:
url = "http://www.theguardian.com/theguardian/{0}/feb/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 3:
url = "http://www.theguardian.com/theguardian/{0}/mar/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 4:
url = "http://www.theguardian.com/theguardian/{0}/apr/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 5:
url = "http://www.theguardian.com/theguardian/{0}/may/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 6:
url = "http://www.theguardian.com/theguardian/{0}/jun/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 7:
url = "http://www.theguardian.com/theguardian/{0}/jul/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 8:
url = "http://www.theguardian.com/theguardian/{0}/aug/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 9:
url = "http://www.theguardian.com/theguardian/{0}/sep/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 10:
url = "http://www.theguardian.com/theguardian/{0}/oct/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 11:
url = "http://www.theguardian.com/theguardian/{0}/nov/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
elif single_date.month == 12:
url = "http://www.theguardian.com/theguardian/{0}/dec/{1}".format(
single_date.strftime('%Y'), single_date.strftime('%d'))
cursor = c.execute(
'SELECT COUNT(*) FROM printNewspaper WHERE url = (?)', (url, ))
articlecount = 0
for row in cursor:
articleCount = int(row[0])
if articleCount == 0:
driver.get(url)
content = driver.page_source
compressedHTMLDump = buffer(
zlib.compress(content.encode('utf8')))
c.execute('INSERT INTO printNewspaper VALUES (?, ?)',
(url, compressedHTMLDump))
time.sleep(randint(120, 300))
except Exception as e:
print e
conn.close()
driver.quit()
xvfbProcess.kill()
xvfbProcess.wait()
def __init__(
self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
incognito=False,
**kwargs
):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
firefox_options = Options()
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override", user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": "1"})
if 'firefox_binary' in kwargs:
if isinstance(kwargs['firefox_binary'], six.string_types):
binary = FirefoxBinary(kwargs['firefox_binary'])
else:
binary = kwargs['firefox_binary']
else:
binary = FirefoxBinary()
binary.add_command_line_options("-headless")
kwargs["firefox_binary"] = binary
if incognito:
firefox_options.add_argument("-private")
self.driver = Firefox(
firefox_profile,
capabilities=firefox_capabilities,
options=firefox_options,
timeout=timeout,
**kwargs
)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def _get_driver(cls,
download_folder,
disable_caching=True,
allow_popups=True,
allow_untrusted_ssl=True,
disable_proxy=False,
driver_executables_folder=None,
cmd_line_args=(),
headless=None,
**kwargs):
"""
Args:
download_folder:
disable_caching:
allow_popups:
allow_untrusted_ssl:
disable_proxy:
driver_executables_folder:
cmd_line_args:
**kwargs: FirefoxDriver kwargs. It can also contain firefox_binary path to the firefox executable in case we want to use a
different version (ie dev version)
Returns:
"""
profile = webdriver.FirefoxProfile()
if headless is None:
headless = settings.HEADLESS
profile.accept_untrusted_certs = allow_untrusted_ssl
profile.assume_untrusted_cert_issuer = allow_untrusted_ssl
preferences = [("browser.helperApps.neverAsk.saveToDisk",
','.join(settings.SELENIUM_MIME_TO_SAVE)),
("browser.download.manager.showWhenStarting", False),
("browser.download.manager.showAlertOnComplete", False),
("browser.download.panel.shown", False),
("browser.download.dir", download_folder),
("browser.download.folderList", 2),
("browser.download.useDownloadDir", True),
("browser.download.closeWhenDone", True),
("browser.helperApps.deleteTempFileOnExit", True),
("browser.download.useWindow", False),
("toolkit.startup.max_resumed_crashes", "-1"),
("browser.allowpopups", allow_popups)]
if disable_caching:
preferences.extend([("browser.cache.disk.enable", False),
("browser.cache.memory.enable", False),
("browser.cache.offline.enable", False),
("network.http.use-cache", False)])
if disable_proxy:
preferences.append(("network.proxy.type", 0))
for k, v in preferences:
profile.set_preference(k, v)
profile.update_preferences()
firefox_binary = FirefoxBinary(kwargs.get('firefox_binary'))
if headless and cls.NATIVE_HEADLESS:
cmd_line_args = list(cmd_line_args)
cmd_line_args.append('--headless')
os.environ['MOZ_HEADLESS'] = 1
if cmd_line_args:
firefox_binary.add_command_line_options(*cmd_line_args)
# https://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/firefox/index.html
return cls(firefox_profile=profile,
executable_path=get_driver_executable_path(
'firefox', driver_executables_folder),
**kwargs)
class TorBrowser:
'''
Refactoring for 2020 12 version of Tor Browser Bundle
'''
def __init__(self,
browser_path,
binary_path=None,
profile_path=None,
executable_path=None,
socks_port=9050,
control_port=9051,
extensions=None,
capabilities=None,
headless=False,
capture_screen=False,
url=None):
assert browser_path is not None
self.browser_path = browser_path
self.binary_path = binary_path
self.profile_path = profile_path
self.executable_path = executable_path
self.socks_port = socks_port
self.control_port = control_port
self.extensions = extensions
self.capabilities = capabilities
self.headless = headless
self.capture_screen = capture_screen
self.url = url
self.profile = None
self.binary = None # firefox
self.options = None
self.webdriver = None
self.tor_controller = TorController() # Start tor process..
self._initialize()
def _initialize(self):
self._init_browser()
self.profile = FirefoxProfile(self.profile_path)
self._init_profile()
self._init_extensions()
self._init_capabilities()
self._init_binary()
self._init_options()
self._init_webdriver()
def _init_browser(self):
if self.binary_path is None:
# tor-browser_en-US/Browser/firefox
self.binary_path = os.path.join(self.browser_path,
os.path.join('Browser', 'firefox'))
if self.profile_path is None:
# tor-browser_en-US/Browser/TorBrowser/Data/Browser/profile.default
self.profile_path = os.path.join(
self.browser_path,
os.path.join(
'Browser',
os.path.join(
'TorBrowser',
os.path.join(
'Data', os.path.join('Browser',
'profile.default')))))
def _init_profile(self):
self.profile.set_preference('browser.cache.disk.enable', False)
self.profile.set_preference('browser.cache.memory.enable', False)
self.profile.set_preference('browser.cache.offline.enable', False)
self.profile.set_preference('browser.startup.page', '0')
self.profile.set_preference('browser.startup.homepage', 'about:newtab')
self.profile.set_preference('network.http.use-cache', False)
self.profile.set_preference('network.proxy.type', 1)
self.profile.set_preference('network.proxy.socks', '127.0.0.1')
self.profile.set_preference('network.proxy.socks_port',
self.socks_port)
self.profile.set_preference('extensions.torlauncher.promp_at_startup',
0)
self.profile.set_preference('network.http.use-cache', False)
self.profile.set_preference('webdriver.load.strategy', 'conservative')
self.profile.set_preference('extensions.torlauncher.start_tor', False)
self.profile.set_preference(
'extensions.torbutton.versioncheck_enabled', False)
self.profile.set_preference('permissions.memory_only', False)
# update_preference('webdriver.load.strategy', 'normal')
# update_preference('app.update.enabled', False)
# update_preference('extensions.torbutton.versioncheck_enabled', False)
# update_preference('extensions.torbutton.prompted_language', True)
# update_preference('extensions.torbutton.socks_port', self.socks_port)
# update_preference('extensions.torlauncher.control_port', self.control_port)
# update_preference('extensions.torlauncher.start_tor', True)
# update_preference('extensions.torbutton.block_dis', False)
# update_preference('extensions.torbutton.custom.socks_host', '127.0.0.1')
# update_preference('extensions.torbutton.custom.socks_port', self.socks_port)
# update_preference('extensions.torbutton.inserted_button', True)
# update_preference('extensions.torbutton.launch_warning', False)
# update_preference('privacy.spoof_english', 2)
# update_preference('extensions.torbutton.loglevel', 2)
# update_preference('extensions.torbutton.logmethod', 0)
# update_preference('extensions.torbutton.settings_method', 'custom')
# update_preference('extensions.torbutton.use_privoxy', False)
# update_preference('extensions.torlauncher.control_port', self.control_port)
# update_preference('extensions.torlauncher.loglevel', 2)
# update_preference('extensions.torlauncher.logmethod', 0)
# update_preference('extensions.torlauncher.prompt_at_startup', False)
self.profile.update_preferences()
def _init_extensions(self):
if self.extensions is not None:
for extension in self.extensions:
self.profile.add_extension(extension)
def _init_capabilities(self):
if self.capabilities is None:
self.capabilities = DesiredCapabilities.FIREFOX
self.capabilities.update({
'handlesAlerts': True,
'databaseEnabled': True,
'javascriptEnabled': True,
'browserConnectionEnabled': True
})
def _init_binary(self):
self.binary = FirefoxBinary(firefox_path=self.binary_path)
self.binary.add_command_line_options('--class', '"Tor Browser"')
def _init_options(self):
if self.headless is True:
self.options = Options()
self.options.headless = self.headless
def _init_webdriver(self):
self.webdriver = webdriver.Firefox(
firefox_profile=self.profile,
firefox_binary=self.binary,
timeout=60,
capabilities=self.capabilities,
executable_path=self.executable_path,
options=self.options)
def connect_url(self, url):
self.webdriver.get(url)
WebDriverWait(self.webdriver, timeout=30).until(
expected_conditions.presence_of_element_located(
(By.TAG_NAME, 'body')))
def close(self):
try:
self.tor_controller.stop()
self.webdriver.quit()
except CannotSendRequest:
logger.error('CannotSendRequest while quitting TorBrowserDriver')
self.binary.kill()
except Exception as e:
logger.error('Exception while quitting TorBrowserDriver', e)
def init_canvas_permission(self, url):
'''
Create a permission DB and add exception for the canvas image extraction.
Otherwise screenshots taken by Selenium will be just blank images due to
canvas fingerprinting defense in Tor Browser Bundle.
'''
import sqlite3
from tld import get_tld
connection = sqlite3.connect
permission_db = connection(
os.path.join(self.profile_path, 'permissions.sqlite'))
cursor = permission_db.cursor()
# http://mxr.mozilla.org/mozilla-esr31/source/build/automation.py.in
cursor.execute("PRAGMA user_version=3")
cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts (
id INTEGER PRIMARY KEY,
host TEXT,
type TEXT,
permission INTEGER,
expireType INTEGER,
expireTime INTEGER,
appId INTEGER,
isInBrowserElement INTEGER)""")
domain = get_tld(url)
logger.debug('Adding canvas/extractData permission for %s' % domain)
query = """INSERT INTO 'moz_hosts' VALUES (NULL, '%s', 'canvas/extractData', 1, 0, 0, 0, 0);""" % domain
cursor.execute(query)
permission_db.commit()
cursor.close()
def take_screenshot(self, save_path):
if save_path is not None:
save_path = os.path.join(save_path, 'screenshot.png')
else:
save_path = 'screenshot.png'
self.webdriver.get_screenshot_as_file(save_path)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
"Resources", "courseart")
CArtResized = " "
global FinalPoster
FinalPoster = os.path.join(PLEXROOT, "Plug-ins", "TGC.bundle", "Contents",
"Resources", "final-")
# Need for ImageMagick to create proper poster art
IMGcmd = [
os.path.abspath(CONVERT), PosterTemplate, CArtResized, '-gravity',
'center', '-composite', FinalPoster
]
RSZcmd = [os.path.abspath(CONVERT), CourseArt, '-resize', '780', CArtResized]
# Firefox and gecko binaries
firefox_binary = FirefoxBinary(os.path.abspath(FIREFOX))
firefox_binary.add_command_line_options('--headless')
gecko_binary = os.path.abspath(GECKODRIVER)
global CURRENTTAB
# Platform
PLATFORM = platform.system()
#CMDFINDER = "where" if platform.system() == "Windows" else "which"
#product_category = {'901' : "Economics & Finance", '902' : 'High School', '904' : 'Fine-Arts', '905' : 'Literature & Language', '907' : 'Philosophy, Intellectual History','909' : 'Religion', '910' : 'Mathematics', '918' : 'History', '926': 'Science', '927': 'Better Living' }
def is_tool(name):
return which(name)
def run():
if tor:
log.info('Getting Tor binary...')
binary = '/Applications/Tor Browser.app/Contents/MacOS/firefox'
if os.path.exists(binary) is False:
raise ValueError("The binary path to Tor firefox does not exist.")
firefox_binary = FirefoxBinary(binary)
firefox_binary.add_command_line_options()
log.info('Starting Tor...')
browser = webdriver.Firefox(firefox_binary=firefox_binary)
log.good('Tor started!')
else:
log.info('Starting Chrome...')
chrome_options = ChromeOptions()
chrome_options.add_argument(
'--disable-blink-features=AutomationControlled')
# chrome_options.add_argument("disable-infobars")
# chrome_options.add_argument("--disable-extensions")
# chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
# chrome_options.add_experimental_option('useAutomationExtension', False)
browser = webdriver.Chrome(options=chrome_options)
log.good("Chrome started!")
# Start
# Gen credentials
credentials = credential_gen.gen_credentials()
username = credentials[0]
password = credentials[1]
date_of_birth = credentials[2]
email = credentials[3]
# Start browser
log.info('Getting twitch.tv...')
browser.get("https://twitch.tv")
sign_up_button = browser.find_element_by_xpath(
'/html/body/div[1]/div/div[2]/nav/div/div[3]/div[3]/div/div[1]/div[2]/button'
)
sign_up_button.click()
log.good("Clicked signup button...")
log.info("Waiting to load signup form...")
time.sleep(3)
# Sign up
# Username
username_field = browser.find_element_by_xpath(
'//*[@id="signup-username"]')
username_field.send_keys(username)
log.good(f'Filled in username: {username}')
# Password
password_field = browser.find_element_by_xpath('//*[@id="password-input"]')
password_field.send_keys(password)
log.good(f'Filled in password: {password}')
# Confirm password
confirm_password_field = browser.find_element_by_xpath(
'//*[@id="password-input-confirmation"]')
confirm_password_field.send_keys(password)
log.good(f'Filled in confirmed password: {password}')
# Date of birth
month = browser.find_element_by_xpath(
f'/html/body/div[3]/div/div/div/div/div/div[1]/div/div/div[3]/form/div/div[3]/div/div[2]/div[1]/select/option[{date_of_birth[0]+1}]'
).click()
day = browser.find_element_by_xpath(
'/html/body/div[3]/div/div/div/div/div/div[1]/div/div/div[3]/form/div/div[3]/div/div[2]/div[2]/div/input'
).send_keys(date_of_birth[1])
year = browser.find_element_by_xpath(
'/html/body/div[3]/div/div/div/div/div/div[1]/div/div/div[3]/form/div/div[3]/div/div[2]/div[3]/div/input'
).send_keys(date_of_birth[2])
# Email
email_field = browser.find_element_by_xpath('//*[@id="email-input"]')
email_field.send_keys(email)
log.good(f'Filled in email: {email}')
log.info('Waiting for submission verification...')
time.sleep(5)
# Submit form
submit_button = browser.find_element_by_xpath(
'/html/body/div[3]/div/div/div/div/div/div[1]/div/div/div[3]/form/div/div[5]/button'
)
submit_button.click()
log.good('Submitted sign up form.')
log.info("Waiting 5 seconds...")
time.sleep(5)
def remind_later():
# Remind to verify later
remind_later = browser.find_element_by_xpath(
'/html/body/div[3]/div/div/div/div/div/div[1]/div/div/div/div/div[3]/div[2]/div/button'
)
remind_later.click()
log.good('Skipped email verification...')
log.log_account(username, email, password)
log.good("Logged account...")
def complete_captcha():
browser.switch_to.frame(
browser.find_element_by_xpath(
'/html/body/div[1]/div[2]/div[1]/iframe'))
audio_captcha_button = browser.find_element_by_xpath(
'//*[@id="fc_meta_audio_btn"]')
audio_captcha_button.click()
time.sleep(.5)
audio_download = browser.find_element_by_xpath(
'//*[@id="audio_download"]')
audio_download.click()
time.sleep(1.5)
# audio_url = 'https://client-api.arkoselabs.com' + browser.find_element_by_xpath('//*[@id="audio_download"]').href
list_of_files = glob.glob('/Users/ismaeel/Downloads/*.wav')
latest_file = max(list_of_files, key=os.path.getctime)
audio_url = '/Users/ismaeel/Downloads/' + latest_file
log.info(f'Captcha audio url: ${audio_url}')
code = arkose_labs.recognize_audio(audio_url)
browser.switch_to.default_content()
try:
remind_later()
except:
input("captcha: ")
# time.sleep(2)
# complete_captcha()
# time.sleep(3)
# remind_later()
# log.info("Waiting 3 seconds...")
# time.sleep(3)
browser.get(f'https://twitch.tv/{user_to_follow}')
time.sleep(1)
# Follow
follow_button = browser.find_element_by_xpath(
'//*[@id="root"]/div/div[2]/div/main/div[2]/div[3]/div/div/div[2]/div[1]/div[2]/div/div[2]/div[1]/div[2]/div[1]/div/div/div/div/div[1]/div/div/div/div/button'
)
follow_button.click()
log.good(f"Followed {user_to_follow}!")
browser.quit()
def __init__(
self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
incognito=False,
**kwargs
):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
firefox_options = Options()
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override", user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": "1"})
binary = FirefoxBinary()
binary.add_command_line_options("-headless")
kwargs["firefox_binary"] = binary
if incognito:
firefox_options.add_argument("-private")
self.driver = Firefox(
firefox_profile,
capabilities=firefox_capabilities,
options=firefox_options,
timeout=timeout,
**kwargs
)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
