def __init__(self,
extra_chrome_flags=[],
subtract_extra_chrome_flags=[],
extension_paths=[],
username=None,
password=None,
server_port=None,
skip_cleanup=False,
url_base=None,
extra_chromedriver_args=None,
gaia_login=False,
disable_default_apps=True,
dont_override_profile=False,
*args,
**kwargs):
"""Initialize.
@param extra_chrome_flags: Extra chrome flags to pass to chrome, if any.
@param subtract_extra_chrome_flags: Remove default flags passed to
chrome by chromedriver, if any.
@param extension_paths: A list of paths to unzipped extensions. Note
that paths to crx files won't work.
@param username: Log in using this username instead of the default.
@param password: Log in using this password instead of the default.
@param server_port: Port number for the chromedriver server. If None,
an available port is chosen at random.
@param skip_cleanup: If True, leave the server and browser running
so that remote tests can run after this script
ends. Default is False.
@param url_base: Optional base url for chromedriver.
@param extra_chromedriver_args: List of extra arguments to forward to
the chromedriver binary, if any.
@param gaia_login: Logs in to real gaia.
@param disable_default_apps: For tests that exercise default apps.
@param dont_override_profile: Don't delete cryptohome before login.
Telemetry will output a warning with this
option.
"""
self._cleanup = not skip_cleanup
assert os.geteuid() == 0, 'Need superuser privileges'
# Log in with telemetry
self._chrome = chrome.Chrome(
extension_paths=extension_paths,
username=username,
password=password,
extra_browser_args=extra_chrome_flags,
gaia_login=gaia_login,
disable_default_apps=disable_default_apps,
dont_override_profile=dont_override_profile)
self._browser = self._chrome.browser
# Close all tabs owned and opened by Telemetry, as these cannot be
# transferred to ChromeDriver.
self._browser.tabs[0].Close()
# Start ChromeDriver server
self._server = chromedriver_server(CHROMEDRIVER_EXE_PATH,
port=server_port,
skip_cleanup=skip_cleanup,
url_base=url_base,
extra_args=extra_chromedriver_args)
# Open a new tab using Chrome remote debugging. ChromeDriver expects
# a tab opened for remote to work. Tabs opened using Telemetry will be
# owned by Telemetry, and will be inaccessible to ChromeDriver.
urllib2.urlopen('http://localhost:%i/json/new' %
utils.get_chrome_remote_debugging_port())
chromeOptions = {
'debuggerAddress':
('localhost:%d' % utils.get_chrome_remote_debugging_port())
}
capabilities = {'chromeOptions': chromeOptions}
# Handle to chromedriver, for chrome automation.
try:
self.driver = webdriver.Remote(command_executor=self._server.url,
desired_capabilities=capabilities)
except NameError:
logging.error('selenium module failed to be imported.')
raise
def setUp(self):
caps = {'browserName': os.getenv('BROWSER', 'chrome')}
self.browser = webdriver.Remote(
command_executor='http://localhost:4444/wd/hub',
desired_capabilities=caps)
def init_driver(program, arguments):
driver = webdriver.Remote(command_executor=APPIUM_URL,
desired_capabilities=desiredCapabilities)
return driver
def __init__(self,
client="firefox",
username="******",
proxy=None,
command_executor=None,
loadstyles=False,
profile=None,
headless=False,
autoconnect=True,
logger=None,
extra_params=None,
chrome_options=None,
executable_path=None):
"""Initialises the webdriver"""
self.logger = logger or self.logger
extra_params = extra_params or {}
if profile is not None:
self._profile_path = profile
self.logger.info("Checking for profile at %s" % self._profile_path)
if not os.path.exists(self._profile_path):
self.logger.critical("Could not find profile at %s" % profile)
raise WhatsAPIException("Could not find profile at %s" %
profile)
else:
self._profile_path = None
self.client = client.lower()
if self.client == "firefox":
if self._profile_path is not None:
self._profile = webdriver.FirefoxProfile(self._profile_path)
else:
self._profile = webdriver.FirefoxProfile()
if not loadstyles:
# Disable CSS
self._profile.set_preference('permissions.default.stylesheet',
2)
# Disable images
self._profile.set_preference('permissions.default.image', 2)
# Disable Flash
self._profile.set_preference(
'dom.ipc.plugins.enabled.libflashplayer.so', 'false')
if proxy is not None:
self.set_proxy(proxy)
options = Options()
if headless:
options.set_headless()
options.profile = self._profile
capabilities = DesiredCapabilities.FIREFOX.copy()
capabilities['webStorageEnabled'] = True
self.logger.info("Starting webdriver")
if executable_path is not None:
executable_path = os.path.abspath(executable_path)
self.logger.info("Starting webdriver")
self.driver = webdriver.Firefox(
capabilities=capabilities,
options=options,
executable_path=executable_path,
**extra_params)
else:
self.logger.info("Starting webdriver")
self.driver = webdriver.Firefox(capabilities=capabilities,
options=options,
**extra_params)
elif self.client == "chrome":
self._profile = webdriver.ChromeOptions()
if self._profile_path is not None:
self._profile.add_argument("user-data-dir=%s" %
self._profile_path)
if proxy is not None:
self._profile.add_argument('--proxy-server=%s' % proxy)
if headless:
self._profile.add_argument('headless')
if chrome_options is not None:
for option in chrome_options:
self._profile.add_argument(option)
self.logger.info("Starting webdriver")
self.driver = webdriver.Chrome(chrome_options=self._profile,
**extra_params)
elif client == 'remote':
if self._profile_path is not None:
self._profile = webdriver.FirefoxProfile(self._profile_path)
else:
self._profile = webdriver.FirefoxProfile()
capabilities = DesiredCapabilities.FIREFOX.copy()
self.driver = webdriver.Remote(command_executor=command_executor,
desired_capabilities=capabilities,
**extra_params)
else:
self.logger.error("Invalid client: %s" % client)
self.username = username
self.wapi_functions = WapiJsWrapper(self.driver, self)
self.driver.set_script_timeout(500)
self.driver.implicitly_wait(10)
if autoconnect:
self.connect()
def getDriver(glob="yes",
host1="local",
type1="chrome",
executer1="default from config file"):
d = None
host = None
type = None
executer = None
if glob == "yes":
host = YamlReader().data['global']['host']
type = YamlReader().data['global']['type']
executer = YamlReader().data['global']['executer']
elif glob == "no":
host = host1
type = type1
executer = executer1
else:
raise "glob值非法！！"
if host == "local":
if type == "chrome":
options = webdriver.ChromeOptions()
prefs = {
'profile.default_content_settings.popups': 0,
'download.default_directory': DATA_PATH
}
options.add_experimental_option('prefs', prefs)
options.add_argument("--start-maximized")
d = webdriver.Chrome(executable_path=CHROMEDRIVER, options=options)
d.maximize_window()
elif type == "firefox":
profile = webdriver.FirefoxProfile()
profile.set_preference("browser.download.folderList", 2)
profile.set_preference("browser.download.manager.showWhenStarting",
False)
profile.set_preference("browser.download.dir", DATA_PATH)
profile.set_preference("browser.helperApps.neverAsk.saveToDisk",
"application/json;charset=UTF-8")
d = webdriver.Firefox(executable_path=FIREFOXDRIVER,
firefox_profile=profile)
d.maximize_window()
elif type == "phantomjs":
d = webdriver.PhantomJS(executable_path=PHANTOMJSDRIVER)
d.maximize_window()
elif type == "ie":
d = webdriver.Ie(executable_path="")
d.maximize_window()
elif host == "remote":
if type == "chrome":
d = webdriver.Remote(
command_executor=executer,
desired_capabilities=DesiredCapabilities.CHROME)
elif type == "firefox":
d = webdriver.Remote(
command_executor=executer,
desired_capabilities=DesiredCapabilities.FIREFOX)
d.maximize_window()
elif type == "phantomjs":
d = webdriver.Remote(
command_executor=executer,
desired_capabilities=DesiredCapabilities.PHANTOMJS)
d.maximize_window()
elif type == "ie":
d = webdriver.Remote(
command_executor=executer,
desired_capabilities=DesiredCapabilities.INTERNETEXPLORER)
d.maximize_window()
else:
raise "host值非法"
return d
def __init__(self, driver="Firefox", leave_host=False, load_images=False,
form_submit_natural_click=False, form_submit_wait=5,
show_browser=False, remote_hub="http://localhost:4444/wd/hub"):
# Needs geckodriver:
# https://github.com/mozilla/geckodriver/releases
# Version 0.20.1 is recommended as of 14/07/2018
if driver == "Firefox":
firefox_options = webdriver.firefox.options.Options()
if not show_browser:
logger.debug("Headless mode enabled")
firefox_options.add_argument("--headless")
firefox_profile = webdriver.FirefoxProfile()
if not load_images:
# disable images
firefox_profile.set_preference(
'permissions.default.image', 2
)
# disable flash
firefox_profile.set_preference(
'dom.ipc.plugins.enabled.libflashplayer.so', 'false'
)
firefox_profile.set_preference(
'security.fileuri.strict_origin_policy', 'false'
)
self.driver = webdriver.Firefox(
firefox_options=firefox_options,
firefox_profile=firefox_profile,
)
# this requires chromedriver to be on the PATH
# if using chromium and ubuntu, apt install chromium-chromedriver
elif driver == "Chrome":
chrome_options = webdriver.ChromeOptions()
if not show_browser:
chrome_options.add_argument("--headless")
chrome_options.add_argument("--window-size=1920x1080")
prefs = {
"profile.managed_default_content_settings.images":2
}
chrome_options.add_experimental_option("prefs",prefs)
self.driver = webdriver.Chrome(chrome_options=chrome_options)
elif driver == "remote":
self.driver = webdriver.Remote(
command_executor=remote_hub,
desired_capabilities={
"browserName": "chrome",
"goog:chromeOptions": {
"args": [
"--disable-logging",
"--headless",
"--window-size=1920x1080",
],
"prefs": {
"profile.managed_default_content_settings.images": 2
},
"extensions": [],
}
})
# set of clicked elements
self.visited = set()
# queue of the path that led us to the current page
# this is in the form of (command, *args, **kwargs)
self.path = []
# sometimes the firefox driver loses its pipe to the browser. in
# these cases, we can retry this number of times
self.broken_pipe_retries = 3
# setting to False, ensures crawl will stay on same host
self.leave_host = leave_host
# characters that need to be escaped if found inside an ID tag
self.css_escapables = ".:"
self.form_submit_natural_click=form_submit_natural_click
self.form_submit_wait=form_submit_wait
def _get_selenium_browser(navigator, fLOG=noLOG):
"""
Returns the associated driver with some custom settings.
The function automatically gets chromedriver if not present (:epkg:`Windows` only).
On :epkg:`Linux`, package *chromium-driver* should be installed:
``apt-get install chromium-driver``.
.. faqref::
:tag: web
:title: Issue with Selenium and Firefox
:lid: faq-web-selenium
Firefox >= v47 does not work on Windows.
See `Selenium WebDriver and Firefox 47 <http://www.theautomatedtester.co.uk/blog/2016/selenium-webdriver-and-firefox-47.html>`_.
Voir `ChromeDriver download <http://chromedriver.storage.googleapis.com/index.html>`_,
`Error message: 'chromedriver' executable needs to be available in the path
<http://stackoverflow.com/questions/29858752/error-message-chromedriver-executable-needs-to-be-available-in-the-path>`_.
See `Selenium - Remote WebDriver example
<https://sauceclient.readthedocs.io/en/latest/selenium_on_sauce.html#selenium-remote-webdriver-example>`_,
see also `Running the remote driver with Selenium and python <https://gist.github.com/alfredo/1962031>`_.
"""
with warnings.catch_warnings():
warnings.simplefilter("ignore", ImportWarning)
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
fLOG("[webshot] navigator=", navigator)
if navigator == "firefox":
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
firefox_capabilities[
'binary'] = r"C:\Program Files (x86)\Mozilla Firefox\firefox.exe"
browser = webdriver.Firefox(capabilities=firefox_capabilities)
elif navigator == "chrome":
if sys.platform.startswith("win"):
chromed = where_in_path("chromedriver.exe")
if chromed is None:
install_chromedriver(fLOG=fLOG)
chromed = where_in_path("chromedriver.exe")
if chromed is None:
raise FileNotFoundError(
"unable to install 'chromedriver.exe'")
else:
fLOG("[_get_selenium_browser] found chromedriver:", chromed)
else:
chromed = 'chromedriver'
start_navi = True
if start_navi:
fLOG("[_get_selenium_browser] start", navigator)
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--verbose')
browser = webdriver.Chrome(executable_path=chromed,
chrome_options=chrome_options)
else:
with warnings.catch_warnings():
warnings.simplefilter("ignore", ImportWarning)
import selenium.webdriver.chrome.service as wservice
fLOG("[_get_selenium_browser] create service")
service = wservice.Service(chromed)
fLOG("[_get_selenium_browser] start service")
service.start()
fLOG("[_get_selenium_browser] declare remote")
capabilities = {'chrome.binary': chromed}
browser = webdriver.Remote(service.service_url, capabilities)
elif navigator == "ie":
browser = webdriver.Ie()
elif navigator == "opera":
if sys.platform.startswith("win"):
chromed = where_in_path("operadriver.exe")
if chromed is None:
install_operadriver(fLOG=fLOG)
chromed = where_in_path("operadriver.exe")
if chromed is None:
raise FileNotFoundError(
"unable to install operadriver.exe")
else:
fLOG("[_get_selenium_browser] found chromedriver:", chromed)
else:
chromed = 'operadriver'
browser = webdriver.Opera(chromed)
elif navigator == "edge":
browser = webdriver.Edge()
else:
raise Exception(
"unable to interpret the navigator '{0}'".format(navigator))
fLOG("[_get_selenium_browser] navigator is started")
return browser
def setUp(self):
self.driver = webdriver.Remote(
command_executor='http://dw-autotest-dev:4444/wd/hub',
desired_capabilities=DesiredCapabilities.FIREFOX)
import time
import random
import webbrowser
import pandas as pd
import urllib.request
from tqdm import tqdm
from bs4 import BeautifulSoup
from urllib.request import Request, urlopen
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
service = Service('/Users/rock/tor/CC_bitChute/chromedriver')
service.start()
driver = webdriver.Remote(service.service_url)
driver.get('https://www.bitchute.com/channel/NaturalNews/')
for i in tqdm(range(15)):
driver.execute_script("window.scrollTo(0, document.body.scrollHeight)")
time.sleep(3)
element = []
for i in driver.find_elements_by_class_name('spa'):
element.append(i)
titles = [x.get_attribute('href') for x in element]
pd.DataFrame(titles).to_csv('BitChuteCC_titles2020.csv', index=False)
titles = pd.read_csv('BitChuteCC_titles2020.csv')
def setUp(self):
self.driver = webdriver.Remote(
command_executor='http://selenium-chrome:4444/wd/hub/',
desired_capabilities=DesiredCapabilities.CHROME)
def setUp(self):
opts = webdriver.FirefoxOptions()
opts.headless = True
self.driver = webdriver.Remote(
command_executor='http://192.168.3.14:4444/wd/hub',
desired_capabilities=opts.to_capabilities())
def __init__(self,
console_url,
webdriver_url=None,
sauce=False,
browser=None,
version=None,
platform=None):
"""
Initiates a tester object. Initiates a copy of the browser. Opens console_url.
:param webdriver_url:
:param console_url:
:param account:
:param user:
:param password:
"""
if sauce is True:
if browser == "ie":
desired_capabilities = webdriver.DesiredCapabilities.INTERNETEXPLORER
elif browser == "chrome":
desired_capabilities = webdriver.DesiredCapabilities.CHROME
else:
desired_capabilities = webdriver.DesiredCapabilities.FIREFOX
desired_capabilities['version'] = version
desired_capabilities['platform'] = platform
desired_capabilities[
'name'] = 'Testing ' + browser + ' ' + version + ' on ' + platform
self.driver = webdriver.Remote(
webdriver_url, desired_capabilities=desired_capabilities)
if sauce is False:
ffprofile = webdriver.FirefoxProfile()
ffprofile.set_preference("browser.download.folderList", 2)
ffprofile.set_preference(
"browser.download.manager.showWhenStarting", False)
ffprofile.set_preference("browser.download.dir", "/tmp/")
ffprofile.set_preference("browser.helperApps.alwaysAsk.force",
False)
ffprofile.set_preference(
"browser.helperApps.neverAsk.saveToDisk",
"application/x-pem-file, text/csv, application/xml, text/plain, image/jpeg, application/x-apple-diskimage, application/zip"
)
desired_capabilities = webdriver.DesiredCapabilities.FIREFOX
desired_capabilities['version'] = version
desired_capabilities['platform'] = platform
#desired_capabilities['name'] = 'Testing ' + browser + ' ' + version + ' on ' + platform
#self.driver = webdriver.Remote(webdriver_url, webdriver.DesiredCapabilities.FIREFOX)
ffprofile.update_preferences()
if webdriver_url is None:
self.driver = webdriver.Firefox(firefox_profile=ffprofile)
print "Using local webdriver"
else:
self.driver = webdriver.Remote(
webdriver_url,
desired_capabilities=desired_capabilities,
browser_profile=ffprofile)
print "Using remote webdriver " + webdriver_url
print "Setting webdriver profile"
self.driver.implicitly_wait(60)
# self.driver.maximize_window()
self.driver.set_window_size(1024, 768)
self.driver.get(console_url)
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
import time
desired_cap = {
'browser': 'Chrome',
'browser_version': '81.0 beta',
'os': 'Windows',
'os_version': '10',
'resolution': '1024x768',
'name': 'Bstack-[Python] Sample Test'
}
driver = webdriver.Remote(
command_executor=
'http://*****:*****@hub.browserstack.com:80/wd/hub',
desired_capabilities=desired_cap)
driver.get('http://akashsuper2000.github.io/faculty-dashboard')
time.sleep(2)
username = driver.find_element_by_name('id')
username.send_keys('sample')
password = driver.find_element_by_name('password')
password.send_keys('password')
time.sleep(2)
subbut = driver.find_element_by_xpath("//input[@type='submit']")
subbut.click()
def setUp(self):
self.driver = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.CHROME)
print("Will use tool '%s'" % (tool.get_name()))
langs = tool.get_available_languages()
print("Available languages: %s" % ", ".join(langs))
lang = langs[0]
print("Will use lang '%s'" % (lang))
print("Starting chrome...")
serv = service.Service('./chromedriver')
serv.start()
capabilities = {
'chrome.binary': '/Applications/Google\ Chrome.app'
}
driver = webdriver.Remote(serv.service_url, capabilities)
driver.get('http://neutral.x0.com/home/sushida/play2.html')
driver.execute_script("document.body.style.zoom = '2.0'")
driver.execute_script('window.scrollTo(230, 250)')
driver.execute_script('window.resizeTo(1050, 750)')
# set up game by hand
time.sleep(12)
# Start game
driver.find_element_by_tag_name("embed").send_keys(Keys.SPACE)
# ready set go
time.sleep(2)
def env_browser(request):
"""Create a webdriver instance of the browser specified by request.
The default browser is Firefox. The webdriver instance is killed after the
number of seconds specified by the ``E2E_WEBDRIVER_TIMEOUT`` variable or
defaults to 300 (five minutes).
"""
timeout = int(os.environ.get('E2E_WEBDRIVER_TIMEOUT', 300))
def wait_kill():
time.sleep(timeout)
browser.quit()
def finalizer():
browser.quit()
timeout_process.terminate()
timeout_process = multiprocessing.Process(target=wait_kill)
sauce_username = os.environ.get('SAUCE_USERNAME', '')
sauce_access_key = os.environ.get('SAUCE_ACCESS_KEY', '')
remote_url = \
"https://%s:%[email protected]:443/wd/hub" \
% (sauce_username, sauce_access_key)
# the desired_capabilities parameter tells us which browsers and OS to spin up.
desired_cap = {
'platform':
'Windows',
'browserName':
'chrome',
'build':
os.environ.get('GITHUB_RUN_ID',
datetime.utcnow().strftime("%Y-%m-%d %H:00ish")),
'name':
request.node.name,
'username':
sauce_username,
'accessKey':
sauce_access_key,
'tunnelIdentifier':
os.environ.get('GITHUB_RUN_ID', ''),
'screenResolution':
'1280x1024'
}
if not RUN_SELENIUM_LOCALLY:
# This creates a webdriver object to send to Sauce Labs including the desired capabilities
browser = webdriver.Remote(remote_url,
desired_capabilities=desired_cap)
else:
# Run tests locally instead of on Sauce Labs (requires local chromedriver installation).
browser = getattr(webdriver, request.param)()
browser.set_window_size(1280, 1024)
# Go to homepage and click cookie accept button so cookie bar is out of the way
browser.get(flask.url_for('hepdata_theme.index', _external=True))
wait = WebDriverWait(browser, 10)
wait.until(
EC.visibility_of_element_located(
(By.CSS_SELECTOR, ".cc_btn_accept_all")))
sleep(1)
cookie_accept_btn = browser.find_element_by_css_selector(
".cc_btn_accept_all")
cookie_accept_btn.click()
# Add finalizer to quit the webdriver instance
request.addfinalizer(finalizer)
timeout_process.start()
yield browser
# Check browser logs before quitting
log = browser.get_log('browser')
assert len(log) == 0, \
"Errors in browser log:\n" + \
"\n".join([f"{line['level']}: {line['message']}" for line in log])
def before_request():
driver = webdriver.Remote(
command_executor=selenium_url,
desired_capabilities=DesiredCapabilities.CHROME.copy())
g.driver = driver
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
import time
options = webdriver.ChromeOptions()
# chrome_options.add_argument("--hide-scrollbars")
# options = webdriver.FirefoxOptions()
driver = webdriver.Remote(command_executor='http://selenium-hub:4444/wd/hub', options=options)
driver.get_window_size()
driver.get("https://www.google.co.jp")
driver.save_screenshot("./screen.png")
print(driver.name)
driver.quit()
from selenium import webdriver from selenium.webdriver import ChromeOptions options = ChromeOptions() desired_caps = options.to_capabilities() desired_caps['platform'] = 'Linux' browser = webdriver.Remote(desired_capabilities=desired_caps)
def browser():
return webdriver.Remote(
command_executor='{}/wd/hub'.format(REMOTE_SELENIUM),
desired_capabilities=DesiredCapabilities.CHROME)
import os
import requests
import ruamel.yaml as yaml
import time
import json
from selenium import webdriver
from selenium.webdriver.common import desired_capabilities
# driver = webdriver.Chrome()
caps = desired_capabilities.DesiredCapabilities.CHROME
driver = webdriver.Remote(command_executor="http://127.0.0.1:4444/wd/hub",
desired_capabilities=caps)
driver.get("https://www.davincilifestyle.com/contracts/acerbis/")
try:
logo_element = driver.find_element_by_css_selector(
".vc_single_image-img.lazyloaded")
logo_link = logo_element.get_attribute("src")
r = requests.get(logo_link, stream=True, allow_redirects=False)
if r.status_code == 200:
open(f'files/logo_test1.jpg', 'wb').write(r.content)
print(f"========== LOGO SUCCESS ==========")
del r
except Exception:
print(f"!!!!!!!!!! LOGO FAILED !!!!!!!!!!")
driver.close()
# with open("lists/brands_list.json", "r") as f:
# brands_list = json.load(f)
# brands_list[time.time()] = time.ctime()
# brands_json = json.dumps(brands_list, indent=4)
# with open("lists/brands_list.json", "w+") as f:
from selenium import webdriver as wd
from selenium.webdriver import DesiredCapabilities
# setup grid in local, refrence :
hubUrl = 'http://169.254.166.115:4444/wd/hub'
capability = DesiredCapabilities.CHROME.copy()
firefoxCaps = DesiredCapabilities.FIREFOX.copy()
ChromeRemoteOPtions = wd.ChromeOptions()
# FFopts = wd.FirefoxOptions()
# ffdriver = wd.Remote(command_executor=hubUrl,desired_capabilities=firefoxCaps,options=FFopts)
# ffdriver.get("http://freecrm.com")
# print(ffdriver.title)
# ffdriver.quit()
driver = wd.Remote(command_executor=hubUrl,
desired_capabilities=capability,
options=ChromeRemoteOPtions)
driver.get("https://freecrm.com")
print(driver.title)
driver.quit()
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
import unittest, time, re
desired_cap = []
desired_cap.append({'browserName': 'chrome', 'platform': 'LINUX'})
desired_cap.append({'browserName': 'firefox', 'platform': 'LINUX'})
for driver_instance in desired_cap:
driver_instance['browserstack.debug'] = True
driver = webdriver.Remote(command_executor='http://localhost:4444/wd/hub',
desired_capabilities=driver_instance)
driver.implicitly_wait(30)
driver.get("http://www.google.com")
search_field = driver.find_element_by_id("lst-ib")
search_field.clear()
search_field.send_keys("Jenkins Selenium WebDriver")
search_field.submit()
driver.get_screenshot_as_file('google.png')
lists = driver.find_elements_by_class_name("_Rm")
print("Found " + str(len(lists)) + "searches:")
from selenium import webdriver
from time import sleep
driver = webdriver.Remote(
command_executor='http://127.0.0.1:32768/wd/hub',
desired_capabilities={'browserName': 'chrome'}
)
driver.get('https://www.baidu.com')
print("get baidu")
driver.find_element_by_id("kw").send_keys("docker selenium")
driver.find_element_by_id("su").click()
sleep(1)
driver.get_screenshot_as_file("/home/fnngj/mypro/baidu_img.png")
driver.quit()
print("end...")
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.CHROME)
browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.OPERA)
browser = webdriver.Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.HTMLUNITWITHJS)
def insta_user_details(chrome_path,
user_urls,
dir_name,
creds,
executor_url=None,
session_id=None):
"""
Take user urls and get follower information
*** NOTE THAT INSTAGRAM WILL BAN AFTER ~ 500 SCRAPED WITHIN AN HOUR. NOT USABLE FOR LARGER SCRAPES
Args:
urls: List of urls for Instagram posts
dir_name: directory to save user_log.csv into
creds: dict with keys user,pass to log into Instagram
executor,session_id: Parameters generated by an existing chromedriver instance. Use if re startng scraping to avoid logging in again.
Returns:
Side Effect:
Saves user_log.csv to dir_name folder with followers per username
"""
if executor_url is None and session_id is None:
options = Options()
# options.add_argument('--headless')
# options.add_argument('--no-sandbox') #removed to see if it would help chrome windows not closing
options.add_argument("--disable-gpu")
# options.add_argument('user-agent=Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Instagram 105.0.0.11.118 (iPhone11,8; iOS 12_3_1; en_US; en-US; scale=2.00; 828x1792; 165586599)')
# options.add_argument('--remote-debugging-port=9222')
# Setup chromedriver. Loop through urls before checking for each item.
browser = Chrome(options=options, executable_path=chrome_path)
print("Executor Url", str(browser.command_executor._url))
print("Session ID:", str(browser.session_id))
browser = login_browser(browser, creds)
else:
# Connect to existing
browser = webdriver.Remote(command_executor=executor_url,
desired_capabilities={})
# browser.close() # this prevents the dummy browser
# browser.session_id = session_id
total_user_details = []
url_count = 0
for url in user_urls:
print(
"\r Processing User: "******"/" +
str(len(user_urls)),
flush=True,
end="",
)
try:
browser.get(url)
followers = browser.find_element_by_xpath(
"""//*[@id="react-root"]/section/main/div/header/section/ul/li[2]/a/span"""
).text
following = browser.find_element_by_xpath(
"""//*[@id="react-root"]/section/main/div/header/section/ul/li[3]/a/span"""
).text
try:
profile = browser.find_element_by_xpath(
"""//*[@id="react-root"]/section/main/div/header/section/div[2]/span"""
).text
except:
print("Issue getting profile statement for account ", url)
profile = ""
user_details = {
"account_name": url.split("/")[-2],
"followers": followers,
"following": following,
"profile": profile,
}
total_user_details.append(user_details)
url_count += 1
time.sleep(5)
if url_count % 100 == 0:
write_to_file(
total_user_details,
os.path.join(dir_name, "user_details.csv"),
fieldnames=[
"account_name", "followers", "following", "profile"
],
)
except:
print("Issues with Profile", url)
browser.close()
write_to_file(
total_user_details,
os.path.join(dir_name, "user_details.csv"),
fieldnames=["account_name", "followers", "following", "profile"],
)
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
driver = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.FIREFOX)
#driver = webdriver.Firefox()
driver.get("http://www.python.org")
assert "Python" in driver.title
# Find <.... name="q" ...> ...</...>
elem = driver.find_element_by_name("q")
print(elem)
# elem is an input, so clear is to clear the input
elem.clear()
# Write "pycon"
elem.send_keys("pycon")
# Press ENTER
elem.send_keys(Keys.RETURN)
# Assert if string in the page
assert "No results found." not in driver.page_source
# Close Selenium driver
results = driver.find_element_by_xpath(
'//[@id="content"]/div/section/form/ul/li[1]/h3')
print(results)
driver.close()
def init_driver():
driver = webdriver.Remote(
command_executor="http://localhost:4444/wd/hub",
desired_capabilities=DesiredCapabilities.FIREFOX,
)
return driver
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
import time
driver = webdriver.Remote(
'http://localhost:4444/wd/hub',
desired_capabilities=webdriver.DesiredCapabilities.CHROME)
driver.get("https://www.w3schools.com/html/default.asp")
time.sleep(5)
all_cookies = driver.get_cookies()
print(all_cookies)
def setUp(self):
opts = webdriver.FirefoxOptions()
opts.add_argument('headless')
self.driver = webdriver.Remote(
command_executor='http://192.168.122.60:4444/wd/hub',
desired_capabilities=opts.to_capabilities())