from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.opera import OperaDriverManager
from webdriver_manager.firefox import GeckoDriverManager
from selenium.webdriver.common.by import By
import time
browser = "chrome"
if browser == 'chrome':
driver = webdriver.Chrome(ChromeDriverManager().install())
elif browser == 'firefox':
driver = webdriver.Firefox(executable_path=GeckoDriverManager().install())
elif browser == 'opera':
driver = webdriver.Opera(executable_path=OperaDriverManager().install())
time.sleep(5)
driver.maximize_window()
driver.get('https://reactquiztype.herokuapp.com/')
print(driver.title)
#css-selector for multiple classes
# driver.find_element(By.CSS_SELECTOR,"button[class*='waves-light']").click()
# xpath with text
# time.sleep(5)
# driver.find_element(By.XPATH,"//button[text()='Submit']").click()
#name
driver.find_element(By.NAME, 'firstname').send_keys('Darshan')
def create_opera(self, desired_capabilities, remote_url, options=None, service_log_path=None):
if is_truthy(remote_url):
defaul_caps = webdriver.DesiredCapabilities.OPERA.copy()
desired_capabilities = self._remote_capabilities_resolver(desired_capabilities, defaul_caps)
return self._remote(desired_capabilities, remote_url, options=options)
return webdriver.Opera(options=options, service_log_path=service_log_path, **desired_capabilities)
from selenium import webdriver
import logging
logger = logging.getLogger('simple_example')
logger.setLevel(logging.INFO)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
logger.addHandler(ch)
fh = logging.FileHandler('Test1OperaLog.log')
fh.setLevel(logging.DEBUG)
logger.addHandler(fh)
driver = webdriver.Opera(executable_path='C:\Drivers\operadriver.exe')
logger.info('Przejscie na stronę Plan Zajęć PJATK')
driver.get('https://planzajec.pjwstk.edu.pl/')
logger.info('Przejscie do planu ogólnego')
temp = driver.find_element_by_link_text('Ogólny plan zajęć')
temp.click()
logger.info('Otwarcie listy miast')
temp = driver.find_element_by_id('WydzialComboBox_Arrow')
temp.click()
logger.info('Wybranie Gdańska')
temp = driver.find_element_by_class_name('rcbItem')
temp.click()
driver.close()
def get_local_driver(browser_name, headless, proxy_string, proxy_auth,
proxy_user, proxy_pass, user_agent, disable_csp,
enable_sync, user_data_dir, extension_zip, extension_dir):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(downloads_path, proxy_string,
user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
make_driver_executable_if_not(LOCAL_GECKODRIVER)
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options,
executable_path=LOCAL_GECKODRIVER)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except WebDriverException:
# Don't use Geckodriver: Only works for old versions of Firefox
profile = _create_firefox_profile(downloads_path, proxy_string,
user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = False
firefox_driver = webdriver.Firefox(
firefox_profile=profile, capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
make_driver_executable_if_not(LOCAL_IEDRIVER)
return webdriver.Ie(capabilities=ie_capabilities,
executable_path=LOCAL_IEDRIVER)
else:
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
# The new Microsoft Edge browser is based on Chromium
chrome_options = _set_chrome_options(downloads_path, headless,
proxy_string, proxy_auth,
proxy_user, proxy_pass,
user_agent, disable_csp,
enable_sync, user_data_dir,
extension_zip, extension_dir)
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER,
options=chrome_options)
else:
return webdriver.Edge()
elif browser_name == constants.Browser.SAFARI:
return webdriver.Safari()
elif browser_name == constants.Browser.OPERA:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
make_driver_executable_if_not(LOCAL_OPERADRIVER)
return webdriver.Opera(executable_path=LOCAL_OPERADRIVER)
else:
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(downloads_path, headless,
proxy_string, proxy_auth,
proxy_user, proxy_pass,
user_agent, disable_csp,
enable_sync, user_data_dir,
extension_zip, extension_dir)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
return webdriver.Chrome(executable_path=LOCAL_CHROMEDRIVER,
options=chrome_options)
else:
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
return webdriver.Chrome(executable_path=LOCAL_CHROMEDRIVER)
else:
return webdriver.Chrome()
else:
raise Exception("%s is not a valid browser option for this system!" %
browser_name)
@author: Janusz
https://stackoverflow.com/questions/43441269/finding-an-element-within-an-element-using-selenium-webdriver
.// search only in parent element
// search whole document
"""
import logging
import time
from collections import namedtuple
import pandas as pd
from selenium import webdriver
logging.basicConfig(level=logging.INFO)
driver = webdriver.Opera()
driver.get("https://tftactics.gg/tierlist/origins")
driver.maximize_window()
time.sleep(3)
accept_all_cookies_button = driver.find_element_by_xpath(
'//a[@class="cmpboxbtn cmpboxbtnyes"]')
accept_all_cookies_button.click()
time.sleep(1)
origin_container_class = "characters-item"
elements_inside_origin_container_class = driver.find_elements_by_class_name(
origin_container_class)
origin_list = []
for element in elements_inside_origin_container_class:
if os.path.join(GlobalUtils.RESOURCES_GECKO32_PATH) in os.environ["PATH"]:
os.environ["PATH"] = os.environ["PATH"].replace(os.pathsep + os.path.join(GlobalUtils.RESOURCES_GECKO32_PATH), "")
if not os.path.join(GlobalUtils.RESOURCES_GECKO64_PATH) in os.environ["PATH"]:
os.environ["PATH"] += os.pathsep + os.path.join(GlobalUtils.RESOURCES_GECKO64_PATH)
_driver = webdriver.Firefox(firefox_profile=profile, capabilities=firefox_capabilities)
else:
raise e
return _driver
elif browser_name == GlobalUtils.BROWSER_NAMES[Browsers.OPERA]:
desired_capabilities = {}
des_caps = _get_browser_options_from_project_xml("default", GlobalUtils.BROWSER_FULL_NAMES[GlobalUtils.BROWSER_NAMES[Browsers.OPERA]],
"desired_capabilities")
for arg in des_caps:
desired_capabilities[arg["option"]] = eval(arg["text"])
_driver = webdriver.Opera(desired_capabilities=desired_capabilities)
return _driver
elif browser_name == GlobalUtils.BROWSER_NAMES[Browsers.ANDROID_CHROME]:
desired_caps = {}
des_caps = _get_browser_options_from_project_xml("default",
GlobalUtils.BROWSER_FULL_NAMES[GlobalUtils.BROWSER_NAMES[Browsers.ANDROID_CHROME]],
"desired_caps")
for arg in des_caps:
desired_caps[arg["option"]] = eval(arg["text"])
_driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)
return _driver
elif browser_name == GlobalUtils.BROWSER_NAMES[Browsers.ANDROID_APPLICATION]:
desired_caps = {}
driver = webdriver.Chrome()
if 'driver' not in locals():
if sys.argv[1].lower() == 'chrome':
driver = webdriver.Chrome()
elif sys.argv[1].lower() == 'firefox':
driver = webdriver.Firefox()
elif sys.argv[1].lower() == 'ie':
driver = webdriver.Ie()
elif sys.argv[1].lower() == 'edge':
driver = webdriver.Edge()
elif sys.argv[1].lower() == 'opera':
options = webdriver.ChromeOptions()
options.binary_location = \
'C:\\Program Files\\Opera\\48.0.2685.50\\opera.exe'
driver = webdriver.Opera(opera_options=options)
# MacOS options
elif sys.argv[1].lower() == 'safari':
driver = webdriver.Safari()
elif sys.argv[1].lower() == 'chromemac':
driver = webdriver.Chrome
('/volumes/OrangeWhite/Dropbox/WebDev/selenium/chromedriver')
# Argument provided didn't match anything above
else:
driver = webdriver.Chrome()
# -----------------------------------------------------------------------------
# Setup and initial URL
# -----------------------------------------------------------------------------
# driver.set_page_load_timeout(30)
driver.get('https://dev.fifteenlines.com/login')
def test_setup():
global driver
driver = webdriver.Opera(
executable_path="/Users/Ms/Selenium webdriver driver/operadriver")
driver.implicitly_wait(10)
driver.maximize_window()
def main(args):
"""Launches DashPi"""
logger = logging.getLogger('DashPi')
# Load the user's configuration file
logger.debug('Loading configuration from "%s"', args.config)
try:
with open(args.config, 'r') as yml:
config = loadconfig(yml)
except IOError:
logger.error('The configuration file "%s" could not be found',
args.config)
return False
# See if the configuration file has debugging set (command line overrides this)
if (ARGS.verbose is None or ARGS.verbose <= 0
) and 'debug' in config and config['debug'] is True:
if 'verbose' in config and config['verbose'] is True:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
# See if a log file is set (command line overrides this)
if ARGS.log is None and 'logfile' in config:
log_file = logging.FileHandler(config['logfile'])
log_file.setFormatter(
logging.Formatter(
fmt=
'[%(asctime)s] %(name)-12s :: %(levelname)-8s : %(message)s',
datefmt='%m-%d-%Y %H:%M:%S'))
logging.getLogger().addHandler(log_file)
logger.debug('Configuration file loaded.')
# Ensure the user has set a browser
if not config or 'browser' not in config or config['browser'] not in [
'firefox', 'iceweasel', 'chrome', 'opera'
]:
logger.error(
'Configuration option "browser" must be one of: firefox, iceweasel, chrome, opera'
)
return False
logger.debug('Browser set to "%s"', config['browser'])
# Get our delay
if 'delay' not in config:
logger.warn('No delay configured, defaulting to 15 seconds')
config['delay'] = 15
if not isinstance(config['delay'], (int, long)) or config['delay'] <= 0:
logger.warn(
'Delay is not a whole, positive number, defaulting to 15 seconds')
config['delay'] = 15
# Ensure we have some dashboards and URLs
if 'dashboards' not in config or not isinstance(
config['dashboards'], list) or len(config['dashboards']) <= 0:
logger.error('No dashboards defined')
return False
# Check if the browser is already running
logger.debug('Checking if browser currently running...')
try:
process = subprocess.check_output(["pgrep", config['browser']])
if process != "":
logger.error(
"The \"%s\" browser is already running, please close and re-run DashPi.",
config['browser'])
return False
except subprocess.CalledProcessError:
logger.debug('Browser not found.')
# Launch the browser
logger.info("Launching %s...", config['browser'])
if config['browser'] == 'chrome':
browser = webdriver.Chrome()
elif config['browser'] == 'opera':
browser = webdriver.Opera() # pylint: disable=redefined-variable-type
else:
browser = webdriver.Firefox() # pylint: disable=redefined-variable-type
# Rotate through URLS
counter = 0
total = len(config['dashboards'])
logger.info("Beginning rotation of %d dashboards at %d second intervals",
total, config['delay'])
while True:
dashboard = config['dashboards'][counter % total]
if 'url' not in dashboard:
logger.warning('URL missing from dashboard #%d, skipping',
(counter % total) + 1)
counter += 1
continue
logger.info("Loading dashboard #%d: %s", (counter % total) + 1,
dashboard['url'])
browser.get(dashboard['url'])
counter += 1
time.sleep(config['delay'])
# Exit
logger.debug('Exiting')
return True
import time
import re
from selenium import webdriver
options = webdriver.ChromeOptions()
options.binary_location = "C:/Program Files/Opera/47.0.2631.80/opera.exe"
driver = webdriver.Opera(
executable_path="C:/02_QA/Selenium/WebDriver/operadriver_2.27.exe",
opera_options=options)
# driver = webdriver.Chrome("C:/02_QA/Selenium/WebDriver/chromedriver.exe")
driver.get("http://www.airindia.in/contact-details.htm")
doc = driver.page_source
emails = re.findall(r'>[\w.-]+@[\w.-]+', doc)
# emails = [1,2,3,4]
for email in emails:
the_string = email[1:]
print(the_string)
time.sleep(2)
driver.quit()
from selenium import webdriver
import pytest
driver = webdriver.Opera(
executable_path="/Users/Ms/Selenium webdriver driver/operadriver")
@pytest.fixture()
def test_setup():
global driver
driver = webdriver.Opera(
executable_path="/Users/Ms/Selenium webdriver driver/operadriver")
driver.implicitly_wait(10)
driver.maximize_window()
def test_AP():
driver.get("http://automationpractice.com/index.php")
def teardown():
driver.close()
driver.quit()
print("Test completed")
from selenium import webdriver
# driver = webdriver.Chrome(executable_path="C:\\chromedriver.exe") # driver is an object of class webdriver
# driver = webdriver.Firefox(executable_path="C:\\geckodriver.exe")
driver = webdriver.Opera(executable_path="C:\\operadriver.exe")
driver.get(
"https://www.facebook.com") # it opens a pop up window with mentioned URL
driver.maximize_window()
print(
driver.title) # show the title of the website, checking it in the console
print(
driver.current_url
) # very useful, normally shows the mentioned URL but when hacked the give the different URL
driver.get("https://www.google.co.in"
) # facebook.com is changed to google.co.in in yhe same window
driver.minimize_window()
driver.back() # back to facebook.com
driver.refresh(
) # if any code there in second url which effect the first one, so it must refresh to get updated data
driver.close(
) # it closes the current window, in programing if we have to open more than one windows and then close
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
chrome_driver_path = "E:/Python/WebDriver/chromedriver.exe"
firefox_driver_path = "E:/Python/WebDriver/geckodriver.exe"
opera_driver_path = "E:/Python/WebDriver/operadriver.exe"
# driver = webdriver.Chrome(executable_path=chrome_driver_path)
# driver = webdriver.Firefox(executable_path=firefox_driver_path)
driver = webdriver.Opera(executable_path=opera_driver_path)
# Test site
# =========
driver.get("https://secure-retreat-92358.herokuapp.com/")
# input_fname = driver.find_element_by_name("fName")
# input_lname = driver.find_element_by_name("lName")
# input_email = driver.find_element_by_name("email")
#
# input_fname.send_keys("John")
# input_lname.send_keys("Private")
# input_email.send_keys("*****@*****.**")
# input_email.submit()
# driver.find_element_by_tag_name("button").click()
# driver.find_element_by_css_selector("form button").click()
input_details = driver.find_element_by_name("fName")
input_details.send_keys("John" + Keys.TAB + "Private" + Keys.TAB + "*****@*****.**" + Keys.ENTER)
# Actual Newsletter Subscription
from math import ceil
import json
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver1 = webdriver.Edge()
driver2 = webdriver.Ie()
options = webdriver.ChromeOptions()
options.binary_location = "C:\\Program Files (x86)\\Opera\\50.0.2762.67\\opera.exe" # path to opera executable
driver3 = webdriver.Opera(options=options)
final_data = []
#final_data['Product'] = []
product_data = {}
review_title_list = []
review_text_list = []
output_file = open('data.json', 'w', encoding='utf-8')
def product_list():
url = "https://www.flipkart.com/air-conditioners/pr?sid=j9e,abm,c54&otracker=categorytree"
driver1.get(url)
total_string = driver1.find_element_by_xpath(
'//div[@class="_1JKxvj _31rYcN"]/span/span')
page_data = str(total_string.text).split(" ")
total_page = int(page_data[3])
page_no = 1
while page_no <= total_page:
print("in while loop product list")
temp_url = url + "&page=" + str(page_no) + "&viewType=list"
# URL Fornat https://assets-runtime-production-oxed-oup.avallain.net/274109_bks_MaaHL_1104_gdc15_xxcg50.pdf
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
options = webdriver.ChromeOptions()
options.add_argument("--start-maximized")
options.add_argument(
"user-data-dir=/Users/aldrin0n9/Documents/Python Projects/Profile")
driver = webdriver.Opera(
executable_path="/Users/aldrin0n9/Documents/Python Projects/operadriver",
options=options)
url = "https://assets-runtime-production-oxed-oup.avallain.net/274109_bks_MaaHL_1104_gdc15_xxcg50.pdf"
for x in range(1, 6):
for y in range(1, 21):
for z in range(100, 120):
url = "https://assets-runtime-production-oxed-oup.avallain.net/274" + str(
z) + "_bks_MaaHL_110" + str(x) + "_gdc" + str(
y) + "_xxcg50.pdf"
driver.get(url)
print(url)
def scrape(browser_driver, driver_path, email, password, output_dir, timeout):
if browser_driver == CHROME:
options = ChromeOptions()
options.add_argument("--headless")
options.add_argument("--window-size=1920,1080")
if driver_path is None:
driver = webdriver.Chrome(options=options)
else:
driver = webdriver.Chrome(executable_path=driver_path,
options=options)
elif browser_driver == FIREFOX:
options = FirefoxOptions()
options.add_argument("--headless")
if driver_path is None:
driver = webdriver.Firefox(options=options)
else:
driver = webdriver.Firefox(executable_path=driver_path,
options=options)
elif browser_driver == SAFARI:
if driver_path is None:
driver = webdriver.Safari()
else:
driver = webdriver.Safari(executable_path=driver_path)
elif browser_driver == OPERA:
if driver_path is None:
driver = webdriver.Opera()
else:
driver = webdriver.Opera(executable_path=driver_path)
else:
raise ValueError(
f'Browser driver has to be one of these: {", ".join(DRIVERS)}')
# Login to LinkedIn
driver.get("https://www.linkedin.com/login/")
driver.find_element_by_id("username").send_keys(email)
driver.find_element_by_id("password").send_keys(password)
driver.find_element_by_class_name("login__form_action_container").submit()
# Check if login is successful
html = driver.page_source.lower()
if any(x in html for x in
["we don't recognize that email", "that's not the right password"]):
driver.quit()
raise LoginError("Invalid login credentials")
# Skip adding a phone number
try:
driver.find_element_by_css_selector(".ember-view.cp-add-phone")
driver.find_element_by_class_name("secondary-action").click()
except NoSuchElementException:
pass
# Navigate to profile page
elem = WebDriverWait(driver, timeout).until(
ec.presence_of_element_located(
(By.CSS_SELECTOR,
".tap-target.block.link-without-hover-visited.ember-view")))
elem.click()
WebDriverWait(driver, timeout).until(
ec.presence_of_element_located((By.ID, "oc-background-section")))
# Scrape profile
profile = {
NAME:
get_personal_details(driver, NAME),
POSITION:
get_personal_details(driver, POSITION),
CONTACT:
get_personal_details(driver, CONTACT, timeout),
SUMMARY:
get_personal_details(driver, SUMMARY),
EXPERIENCE:
get_background_details(driver, By.ID, "experience-section",
EXPERIENCE),
EDUCATION:
get_background_details(driver, By.ID, "education-section", EDUCATION),
VOLUNTEERING:
get_background_details(
driver,
By.CSS_SELECTOR,
".pv-profile-section.volunteering-section.ember-view",
VOLUNTEERING,
),
SKILLS:
get_background_details(
driver,
By.CSS_SELECTOR,
".pv-profile-section.pv-skill-categories-section.artdeco-container-card.ember-view",
SKILLS,
),
PROJECTS:
get_accomplishment_details(driver, PROJECTS),
PUBLICATIONS:
get_accomplishment_details(driver, PUBLICATIONS),
HONORS:
get_accomplishment_details(driver, HONORS),
LANGUAGES:
get_accomplishment_details(driver, LANGUAGES),
}
driver.quit()
with open(os.path.join(output_dir, "profile.json"), "w") as f:
json.dump(profile, f, indent=4)
return profile
def start_webdriver_client(self):
capabilities = {}
for c in self.capabilities:
name, value = c.split(':')
# handle integer capabilities
if value.isdigit():
value = int(value)
# handle boolean capabilities
elif value.lower() in ['true', 'false']:
value = value.lower() == 'true'
capabilities.update({name: value})
if self.proxy_host and self.proxy_port:
proxy = Proxy()
proxy.http_proxy = '%s:%s' % (self.proxy_host, self.proxy_port)
proxy.ssl_proxy = proxy.http_proxy
proxy.add_to_capabilities(capabilities)
profile = None
if self.driver.upper() == 'REMOTE':
capabilities.update(getattr(webdriver.DesiredCapabilities, self.browser_name.upper()))
if json.loads(self.chrome_options) or self.extension_paths:
capabilities = self.create_chrome_options(
self.chrome_options,
self.extension_paths).to_capabilities()
if self.browser_name.upper() == 'FIREFOX':
profile = self.create_firefox_profile(
self.firefox_preferences,
self.profile_path,
self.extension_paths)
if self.browser_version:
capabilities['version'] = self.browser_version
capabilities['platform'] = self.platform.upper()
executor = 'http://%s:%s/wd/hub' % (self.host, self.port)
try:
self.selenium = webdriver.Remote(command_executor=executor,
desired_capabilities=capabilities or None,
browser_profile=profile)
except AttributeError:
valid_browsers = [attr for attr in dir(webdriver.DesiredCapabilities) if not attr.startswith('__')]
raise AttributeError("Invalid browser name: '%s'. Valid options are: %s" % (self.browser_name, ', '.join(valid_browsers)))
elif self.driver.upper() == 'CHROME':
options = None
if self.chrome_options or self.extension_paths:
options = self.create_chrome_options(
self.chrome_options,
self.extension_paths)
if self.chrome_path:
self.selenium = webdriver.Chrome(executable_path=self.chrome_path,
chrome_options=options,
desired_capabilities=capabilities or None)
else:
self.selenium = webdriver.Chrome(chrome_options=options,
desired_capabilities=capabilities or None)
elif self.driver.upper() == 'FIREFOX':
binary = self.firefox_path and FirefoxBinary(self.firefox_path) or None
profile = self.create_firefox_profile(
self.firefox_preferences,
self.profile_path,
self.extension_paths)
self.selenium = webdriver.Firefox(
firefox_binary=binary,
firefox_profile=profile,
capabilities=capabilities or None)
elif self.driver.upper() == 'IE':
self.selenium = webdriver.Ie()
elif self.driver.upper() == 'OPERA':
capabilities.update(webdriver.DesiredCapabilities.OPERA)
self.selenium = webdriver.Opera(executable_path=self.opera_path,
desired_capabilities=capabilities)
else:
self.selenium = getattr(webdriver, self.driver)()
if self.event_listener is not None and not isinstance(self.selenium, EventFiringWebDriver):
self.selenium = EventFiringWebDriver(self.selenium, self.event_listener())
def __init__(self,
browser='ff',
remote_address=None,
driver: WebDriver = None):
t1 = datetime.now()
dc = {
'platform': 'ANY',
'browserName': 'chrome',
'version': '',
'javascriptEnabled': True
}
if driver == None:
if remote_address is None:
if browser == "firefox" or browser == "ff":
self.driver = webdriver.Firefox()
elif browser == "headless chrome" or browser == "headless Chrome" or browser == "headless_chrome" or browser == "headless_Chrome":
options = Options()
options.add_argument('--headless')
options.add_argument('--disable-gpu')
self.driver = webdriver.Chrome(executable_path=driver_path,
options=options)
elif browser == "chrome" or browser == "Chrome":
options = Options()
# 用于浏览器复用
# options.debugger_address = "127.0.0.1:9999"
options.add_argument("--disable-infobars")
options.add_argument("start-maximized")
options.add_argument("--disable-extensions")
# 1-allow;2-disable 强制打开Chrome浏览器的mic和camera权限，不需要单独点击允许或拒绝
options.add_experimental_option(
"prefs", {
"profile.default_content_setting_values.media_stream_mic":
1,
"profile.default_content_setting_values.media_stream_camera":
1,
"profile.default_content_setting_values.geolocation":
1,
"profile.default_content_setting_values.notifications":
1
})
self.driver = webdriver.Chrome(executable_path=driver_path,
options=options)
elif browser == "internet explorer" or browser == "ie":
self.driver = webdriver.Ie()
elif browser == "opera":
self.driver = webdriver.Opera()
elif browser == "phantomjs":
self.driver = webdriver.PhantomJS()
elif browser == "edge":
self.driver = webdriver.Edge()
else:
if browser == "RChrome":
self.driver = webdriver.Remote(command_executor='http://' +
remote_address + '/wd/hub',
desired_capabilities=dc)
elif browser == "RIE":
dc['browserName'] = 'internet explorer'
self.driver = webdriver.Remote(command_executor='http://' +
remote_address + '/wd/hub',
desired_capabilities=dc)
elif browser == "RFirefox":
dc['browserName'] = 'firefox'
dc['marionette'] = False
self.driver = webdriver.Remote(command_executor='http://' +
remote_address + '/wd/hub',
desired_capabilities=dc)
try:
self.driver.implicitly_wait(5)
my_print("Success Start a new browser:{0} , Spend {1} seconds".
format(browser, (datetime.now() - t1).seconds))
except Exception:
raise NameError(
"Not found {0} browser,You can enter 'ie','ff',"
"'chrome','RChrome','RIe' or 'RFirefox'.".format(browser))
else:
self.driver = driver
def get_local_driver(browser_name, headless, locale_code, servername,
proxy_string, proxy_auth, proxy_user, proxy_pass,
user_agent, disable_csp, enable_ws, enable_sync,
use_auto_ext, no_sandbox, disable_gpu, incognito,
guest_mode, devtools, swiftshader, block_images,
user_data_dir, extension_zip, extension_dir,
mobile_emulator, device_width, device_height,
device_pixel_ratio):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(downloads_path, locale_code,
proxy_string, user_agent,
disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
firefox_capabilities['moz:firefoxOptions'] = ({
'args': ['-headless']
})
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
try:
make_driver_executable_if_not(LOCAL_GECKODRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make geckodriver"
" executable: %s" % e)
elif not is_geckodriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: geckodriver not found!"
" Installing now:")
try:
sb_install.main(override="geckodriver")
except Exception as e:
print("\nWarning: Could not install geckodriver: "
"%s" % e)
sys.argv = sys_args # Put back the original sys args
if "linux" in PLATFORM or not headless:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except Exception:
profile = _create_firefox_profile(downloads_path, locale_code,
proxy_string, user_agent,
disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_driver = webdriver.Firefox(
firefox_profile=profile, capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
try:
make_driver_executable_if_not(LOCAL_IEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make iedriver"
" executable: %s" % e)
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
try:
chrome_options = _set_chrome_options(
browser_name, downloads_path, headless, locale_code,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext, no_sandbox,
disable_gpu, incognito, guest_mode, devtools, swiftshader,
block_images, user_data_dir, extension_zip, extension_dir,
servername, mobile_emulator, device_width, device_height,
device_pixel_ratio)
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
elif not is_edgedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: msedgedriver not found. Installing now:")
sb_install.main(override="edgedriver")
sys.argv = sys_args # Put back the original sys args
# For Microsoft Edge (Chromium) version 79 or lower
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER,
options=chrome_options)
except Exception:
# For Microsoft Edge (Chromium) version 80 or higher
from msedge.selenium_tools import Edge, EdgeOptions
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
edge_options = EdgeOptions()
edge_options.use_chromium = True
prefs = {
"download.default_directory": downloads_path,
"local_discovery.notifications_enabled": False,
"credentials_enable_service": False,
"download.prompt_for_download": False,
"download.directory_upgrade": True,
"safebrowsing.enabled": False,
"safebrowsing.disable_download_protection": True,
"profile": {
"password_manager_enabled": False
}
}
if locale_code:
prefs["intl.accept_languages"] = locale_code
if block_images:
prefs["profile.managed_default_content_settings.images"] = 2
edge_options.add_experimental_option("prefs", prefs)
edge_options.add_experimental_option("w3c", True)
edge_options.add_experimental_option("useAutomationExtension",
False)
edge_options.add_experimental_option(
"excludeSwitches", ["enable-automation", "enable-logging"])
if guest_mode:
edge_options.add_argument("--guest")
if headless:
edge_options.add_argument("--headless")
if mobile_emulator:
emulator_settings = {}
device_metrics = {}
if type(device_width) is int and (
type(device_height) is int and
(type(device_pixel_ratio) is int)):
device_metrics["width"] = device_width
device_metrics["height"] = device_height
device_metrics["pixelRatio"] = device_pixel_ratio
else:
device_metrics["width"] = 411
device_metrics["height"] = 731
device_metrics["pixelRatio"] = 3
emulator_settings["deviceMetrics"] = device_metrics
if user_agent:
emulator_settings["userAgent"] = user_agent
edge_options.add_experimental_option("mobileEmulation",
emulator_settings)
edge_options.add_argument("--enable-sync")
edge_options.add_argument("--disable-infobars")
edge_options.add_argument("--disable-save-password-bubble")
edge_options.add_argument("--disable-single-click-autofill")
edge_options.add_argument(
"--disable-autofill-keyboard-accessory-view[8]")
edge_options.add_argument("--disable-translate")
if not enable_ws:
edge_options.add_argument("--disable-web-security")
edge_options.add_argument("--homepage=about:blank")
edge_options.add_argument("--dns-prefetch-disable")
edge_options.add_argument("--dom-automation")
edge_options.add_argument("--disable-hang-monitor")
edge_options.add_argument("--disable-prompt-on-repost")
if proxy_string:
edge_options.add_argument('--proxy-server=%s' % proxy_string)
edge_options.add_argument("--test-type")
edge_options.add_argument("--log-level=3")
edge_options.add_argument("--no-first-run")
edge_options.add_argument("--ignore-certificate-errors")
if devtools and not headless:
edge_options.add_argument("--auto-open-devtools-for-tabs")
edge_options.add_argument("--allow-file-access-from-files")
edge_options.add_argument("--allow-insecure-localhost")
edge_options.add_argument("--allow-running-insecure-content")
if user_agent:
edge_options.add_argument("--user-agent=%s" % user_agent)
edge_options.add_argument("--no-sandbox")
if swiftshader:
edge_options.add_argument("--use-gl=swiftshader")
else:
edge_options.add_argument("--disable-gpu")
if "linux" in PLATFORM:
edge_options.add_argument("--disable-dev-shm-usage")
capabilities = edge_options.to_capabilities()
capabilities["platform"] = ''
return Edge(executable_path=LOCAL_EDGEDRIVER,
capabilities=capabilities)
elif browser_name == constants.Browser.SAFARI:
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join) or (arg_join == "-c"):
# Skip if multithreaded
raise Exception("Can't run Safari tests in multi-threaded mode!")
safari_capabilities = _set_safari_capabilities()
return webdriver.Safari(desired_capabilities=safari_capabilities)
elif browser_name == constants.Browser.OPERA:
try:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
try:
make_driver_executable_if_not(LOCAL_OPERADRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make operadriver"
" executable: %s" % e)
opera_options = _set_chrome_options(
browser_name, downloads_path, headless, locale_code,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext, no_sandbox,
disable_gpu, incognito, guest_mode, devtools, swiftshader,
block_images, user_data_dir, extension_zip, extension_dir,
servername, mobile_emulator, device_width, device_height,
device_pixel_ratio)
opera_options.headless = False # No support for headless Opera
return webdriver.Opera(options=opera_options)
except Exception:
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(
browser_name, downloads_path, headless, locale_code,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext, no_sandbox,
disable_gpu, incognito, guest_mode, devtools, swiftshader,
block_images, user_data_dir, extension_zip, extension_dir,
servername, mobile_emulator, device_width, device_height,
device_pixel_ratio)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
elif not is_chromedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: chromedriver not found. Installing now:")
sb_install.main(override="chromedriver")
sys.argv = sys_args # Put back the original sys args
if not headless or "linux" not in PLATFORM:
return webdriver.Chrome(options=chrome_options)
else: # Running headless on Linux
try:
return webdriver.Chrome(options=chrome_options)
except Exception:
# Use the virtual display on Linux during headless errors
logging.debug("\nWarning: Chrome failed to launch in"
" headless mode. Attempting to use the"
" SeleniumBase virtual display on Linux...")
chrome_options.headless = False
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
return webdriver.Chrome()
else:
raise Exception("%s is not a valid browser option for this system!" %
browser_name)
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.select import Select # verify if tag is a 'select'
from selenium.webdriver.support.ui import WebDriverWait # makes webdrive wait page load
from selenium.webdriver.support import expected_conditions as ec # verify if expected conditions is valid
from selenium.webdriver.opera.options import Options # opera webdriver options
from webdriver_manager.opera import OperaDriverManager # opera webdriver manager
import json # manipulate JSON files
from xhtml2pdf import pisa # to build PDF with HTML
""" get HTML content """
url = "https://www.nba.com/stats/players/traditional/?sort=PLAYER_NAME&dir=-1" # NBA tabledata URL
option = Options()
option.headless = True # execute without graphical interface
driver = webdriver.Opera(
options=option) # call the webdriver to open the browser and get the URL
#driver = webdriver.Opera(OperaDriverManager().install(), options=option) # call the webdriver - installed on cache by driver manager - to open the browser and get the URL
driver.get(url)
time.sleep(10) # delay do get data
driver.find_element_by_xpath(
"//div[@class='nba-stat-table']//table//thead//tr//th[@data-field='PTS']"
).click() # emulate click to sort by poits
element = driver.find_element_by_xpath("//div[@class='nba-stat-table']//table")
html_content = element.get_attribute("outerHTML") # html table content
""" parse to BS4 HTML structure """
soup = BeautifulSoup(html_content, features='lxml')
table = soup.find(name='table')
def create_opera(self, desired_capabilities, remote_url):
default = webdriver.DesiredCapabilities.OPERA
if is_truthy(remote_url):
return self._remote(default, desired_capabilities, remote_url)
capabilities = self._combine_capabilites(default, desired_capabilities)
return webdriver.Opera(desired_capabilities=capabilities)
def start(self):
"""Starts Selenium and (optionally) starts XVFB first.
Note:
XVFB is typically used with headless runs. If you do not use XVFB
and the browser you have selected has a GUI (Firefox, Chrome...)
then your browser will launch and you will be able to view the
test as it is being ran.
This is particularly useful for problematic test runs or when building
new tests.
"""
if self.xvfb:
try:
print("Starting XVFB display...")
self.display = Xvfb(width=self.width,
height=self.height,
colordepth=16)
try:
self.display.start()
except OSError:
self.xvfb = False
print(
"Unable to start XVFB. Try running `./build/selenium.sh`"
)
except EnvironmentError:
print("Skipping XVFB run since it is not present.")
self.xvfb = False
print("Starting browser ({})...".format(self.driver))
if self.driver == "PhantomJS":
self.browser = webdriver.PhantomJS()
elif self.driver == "Chrome":
self.browser = webdriver.Chrome()
elif self.driver == "Opera":
self.browser = webdriver.Opera()
elif self.driver == "Ie":
self.browser = webdriver.Ie()
elif self.driver == "Remote":
if isinstance(self.desired_capabilities, dict):
dc = self.desired_capabilities
else:
dcu = self.desired_capabilities.upper()
if dcu == 'IE':
dcu = 'INTERNETEXPLORER'
dc = getattr(DesiredCapabilities, dcu)
self.browser = webdriver.Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=dc)
elif self.driver == 'Firefox':
# Get rid of the annoying start page by setting preferences
fp = webdriver.FirefoxProfile()
fp.set_preference("browser.startup.homepage_override.mstone",
"ignore")
fp.set_preference("startup.homepage_welcome_url.additional",
"about:blank")
self.browser = webdriver.Firefox(firefox_profile=fp)
else:
raise UserWarning('No valid driver detected.')
def get_local_driver(browser_name, headless, servername, proxy_string,
proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_sync, use_auto_ext, no_sandbox,
disable_gpu, incognito, guest_mode, devtools,
user_data_dir, extension_zip, extension_dir,
mobile_emulator, device_width, device_height,
device_pixel_ratio):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(downloads_path, proxy_string,
user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
firefox_capabilities['moz:firefoxOptions'] = ({
'args': ['-headless']
})
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
try:
make_driver_executable_if_not(LOCAL_GECKODRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make geckodriver"
" executable: %s" % e)
elif not is_geckodriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: geckodriver not found!"
" Installing now:")
try:
sb_install.main(override="geckodriver")
except Exception as e:
print("\nWarning: Could not install geckodriver: "
"%s" % e)
sys.argv = sys_args # Put back the original sys args
if "linux" in PLATFORM or not headless:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except Exception:
profile = _create_firefox_profile(downloads_path, proxy_string,
user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_driver = webdriver.Firefox(
firefox_profile=profile, capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
try:
make_driver_executable_if_not(LOCAL_IEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make iedriver"
" executable: %s" % e)
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
try:
chrome_options = _set_chrome_options(
downloads_path, headless, proxy_string, proxy_auth, proxy_user,
proxy_pass, user_agent, disable_csp, enable_sync, use_auto_ext,
no_sandbox, disable_gpu, incognito, guest_mode, devtools,
user_data_dir, extension_zip, extension_dir, servername,
mobile_emulator, device_width, device_height,
device_pixel_ratio)
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
elif not is_edgedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: msedgedriver not found. Installing now:")
sb_install.main(override="edgedriver")
sys.argv = sys_args # Put back the original sys args
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER,
options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER)
elif browser_name == constants.Browser.SAFARI:
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join) or (arg_join == "-c"):
# Skip if multithreaded
raise Exception("Can't run Safari tests in multi-threaded mode!")
safari_capabilities = _set_safari_capabilities()
return webdriver.Safari(desired_capabilities=safari_capabilities)
elif browser_name == constants.Browser.OPERA:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
try:
make_driver_executable_if_not(LOCAL_OPERADRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make operadriver"
" executable: %s" % e)
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(
downloads_path, headless, proxy_string, proxy_auth, proxy_user,
proxy_pass, user_agent, disable_csp, enable_sync, use_auto_ext,
no_sandbox, disable_gpu, incognito, guest_mode, devtools,
user_data_dir, extension_zip, extension_dir, servername,
mobile_emulator, device_width, device_height,
device_pixel_ratio)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
elif not is_chromedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: chromedriver not found. Installing now:")
sb_install.main(override="chromedriver")
sys.argv = sys_args # Put back the original sys args
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
return webdriver.Chrome()
else:
raise Exception("%s is not a valid browser option for this system!" %
browser_name)
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from time import sleep
import sys
name = sys.argv[1]
driver = webdriver.Opera(executable_path='./operadriver.exe')
driver.get('https://events.webinar.ru/19563399/3590720')
form_element = driver.find_element_by_id('name')
form_element.send_keys(name)
form_element.send_keys(u'\ue007')
element = WebDriverWait(driver, 15).until(
EC.presence_of_element_located(
(By.CLASS_NAME, "Reaction__rippleContainer___gaQaA")))
hot = driver.find_elements_by_class_name(
"Reaction__rippleContainer___gaQaA")[0]
for i in range(400):
hot.click()
sleep(.1)
def getWebDriverInstance(self):
"""
Get WebDriver Instance based on the browser configuration
Returns:
'WebDriver Instance'
"""
strver = 'version'
if self.browser == "iexplorer" or self.browser == "ie" or self.browser == "IE":
# Set IE driver
iedriverserver = r'C:\tools\Python36\Scripts\IEDriverServer_x64_2.42.0.exe'
# iedriverserver = r'C:\tools\Python36\Scripts\IEDriverServer_x64_3.12.0.exe' ## not working
# iedriverserver = r'C:\tools\Python36\Scripts\IEDriverServer_x32_3.4.0.exe' ## work but 32bit
driver = webdriver.Ie(iedriverserver)
elif self.browser == 'safari': ### Safari not working on Windows - need Safari 10 on OSX El Capitan
safaridriver = r'C:\tools\Python36\Scripts\SafariDriver.exe'
driver = webdriver.Safari(safaridriver)
elif self.browser == 'opera':
# OperaDriver - win64 2.36 - https://github.com/operasoftware/operachromiumdriver/releases
_operaDriverLoc = r'C:\tools\Python36\Scripts\operadriver_win64_2.36.exe'
# Opera browser # Version: 53.0.2907.68 # System: Windows 7 64-bit
_operaExeLoc = r'C:\Program Files\Opera\53.0.2907.68\opera.exe'
from selenium.webdriver.common import desired_capabilities as operacapabilities
from selenium.webdriver.opera import options as operaoptions
_operaCaps = operacapabilities.DesiredCapabilities.OPERA.copy()
_operaOpts = operaoptions.ChromeOptions()
_operaOpts._binary_location = _operaExeLoc
# driver = webdriver.Chrome(executable_path = _operaDriverLoc, chrome_options = _operaOpts, desired_capabilities = _operaCaps)
driver = webdriver.Opera(executable_path=_operaDriverLoc,
options=_operaOpts,
desired_capabilities=_operaCaps)
elif self.browser == "firefox" or self.browser == "ff":
driver = webdriver.Firefox()
strver = 'browserVersion'
elif self.browser == "chrome":
# Set chrome driver
chromedriver = r'C:\tools\Python36\Scripts\chromedriver.exe'
#os.environ["webdriver.chrome.driver"] = chromedriver
chrome_options = webdriver.ChromeOptions()
# chrome_options.add_argument('--disable-extensions')
#chrome_options.add_argument('--profile-directory=Default')
chrome_options.add_argument("--incognito")
# chrome_options.add_argument("--disable-plugins-discovery")
# chrome_options.add_argument("--start-maximized")
driver = webdriver.Chrome(chromedriver,
chrome_options=chrome_options)
#driver.set_window_size(1440, 900)
elif self.browser == "headless" or self.browser == "nobrowser" or self.browser == "virtual":
# This is for running without open Browser UI display - good for Jenkins
chromedriver = r'C:\tools\Python36\Scripts\chromedriver.exe'
chrome_options = webdriver.ChromeOptions()
# chrome_options.add_argument('--disable-extensions')
chrome_options.add_argument("--incognito")
# chrome_options.add_argument("--disable-plugins-discovery")
# chrome_options.add_argument("--start-maximized")
chrome_options.add_argument('--headless')
chrome_options.add_argument("--proxy-server='direct://'")
chrome_options.add_argument("--proxy-bypass-list=*")
driver = webdriver.Chrome(chromedriver,
chrome_options=chrome_options)
else:
driver = webdriver.Firefox()
strver = 'browserVersion'
# Setting Driver Implicit Time out for An Element
driver.implicitly_wait(3)
# Maximize the window
# driver.maximize_window()
print('Browser version ( ' + driver.name + ' ) = ' +
driver.capabilities[strver])
return driver
def create_opera(self, desired_capabilities, remote_url):
if is_truthy(remote_url):
defaul_caps = webdriver.DesiredCapabilities.OPERA.copy()
desired_capabilities = self._remote_capabilities_resolver(desired_capabilities, defaul_caps)
return self._remote(desired_capabilities, remote_url)
return webdriver.Opera(**desired_capabilities)
def __init__(self, browser='ff', headless=False, remoteAddress=None):
"""
remote consle：
dr = PySelenium('RChrome','127.0.0.1:8080')
"""
t1 = time.time()
dc = {
'platform': 'ANY',
'browserName': 'chrome',
'version': '',
'javascriptEnabled': True}
dr = None
# 设置日志路径
geckodriver_log_path = globalparam.log_path
logname_geckodriver = os.path.join(
geckodriver_log_path, 'geckodriver_' + '{0}.log'.format(
time.strftime('%Y-%m-%d')))
if remoteAddress is None:
if browser == "firefox" or browser == "ff":
if headless:
firfox_option = webdriver.FirefoxOptions()
firfox_option.add_argument("--headless") # 设置火狐为headless无界面模式
firfox_option.add_argument("--disable-gpu")
dr = webdriver.Firefox(
service_log_path=logname_geckodriver,
options=firfox_option)
else:
dr = webdriver.Firefox(
service_log_path=logname_geckodriver)
elif browser == "chrome" or browser == "Chrome":
if headless:
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument("--headless")# 设置chrome为headless无界面模式
chrome_options.add_argument("--disable-gpu")
dr = webdriver.Chrome(chrome_options=chrome_options)
else:
dr = webdriver.Chrome()
elif browser == "internet explorer" or browser == "ie":
dr = webdriver.Ie()
elif browser == "opera":
dr = webdriver.Opera()
elif browser == "phantomjs":
dr = webdriver.PhantomJS()
elif browser == "edge":
dr = webdriver.Edge()
else:
if browser == "RChrome":
dr = webdriver.Remote(
command_executor='http://' +
remoteAddress +
'/wd/hub',
desired_capabilities=dc)
elif browser == "RIE":
dc['browserName'] = 'internet explorer'
dr = webdriver.Remote(
command_executor='http://' +
remoteAddress +
'/wd/hub',
desired_capabilities=dc)
elif browser == "RFirefox":
dc['browserName'] = 'firefox'
dc['marionette'] = False
dr = webdriver.Remote(
command_executor='http://' +
remoteAddress +
'/wd/hub',
desired_capabilities=dc)
try:
self.driver = dr
self.my_print(
"{0} Start a new browser: {1}, Spend {2} seconds".format(
success, browser, time.time() - t1))
except Exception:
raise NameError(
"Not found {0} browser,You can enter 'ie','ff',"
"'chrome','RChrome','RIe' or 'RFirefox'.".format(browser))
def open_browser(self):
self.d = webdriver.Opera(options=self.options)
from selenium import webdriver
import time
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
try:
#ссылка на вход и драйвер
link = "http://web01/Energy_test/Account/Login"
browser = webdriver.Opera()
browser.get(link)
browser.maximize_window()
#ввод логина
lg_element = browser.find_element_by_id("UserName")
lg_element.send_keys("bel_pnpo")
#ввод пароля
ps_element = browser.find_element_by_id("Password")
ps_element.send_keys("Qwerty12345")
#нажимаем кнопку "Вход"
button = browser.find_element_by_id("btnSignIn")
button.click()
#Выбираем программу 2020-2024
combo_prog_name = browser.find_element_by_id("combo_prog_name")
combo_prog_name.click()
time.sleep(5)
prog20_button = browser.find_element_by_xpath(
"/html/body/div[1]/div[1]/div[1]/div/ul/li[6]/span")
prog20_button.click()
def getWebDriverInstance(self, baseURL):
"""
Get WebDriver Instance based on the browser configuration
Returns:
'WebDriver Instance'
"""
# strver = 'version'
strver = 'browserVersion'
driver_name = 'unknown'
driver_version = 'unknown'
if self.browser == "iexplorer" or self.browser == "ie" or self.browser == "IE":
# Set IE driver
iedriverserver = r'C:\tools\Python36\Scripts\IEDriverServer_x64_2.42.0.exe'
# iedriverserver = r'C:\tools\Python36\Scripts\IEDriverServer_x64_3.12.0.exe' ## not working
# iedriverserver = r'C:\tools\Python36\Scripts\IEDriverServer_x32_3.4.0.exe' ## work but 32bit
driver = webdriver.Ie(iedriverserver)
elif self.browser == 'safari': ### Safari not working on Windows - need Safari 10 on OSX El Capitan
safaridriver = r'C:\tools\Python36\Scripts\SafariDriver.exe'
driver = webdriver.Safari(safaridriver)
elif self.browser == 'opera':
# OperaDriver - win64 2.36 - https://github.com/operasoftware/operachromiumdriver/releases
from os import listdir
from selenium.webdriver.common import desired_capabilities as operacapabilities
from selenium.webdriver.opera import options as operaoptions
# OperaDriver - win64 2.36 - https://github.com/operasoftware/operachromiumdriver/releases
_operaDriverLoc = r'C:\tools\Python36\Scripts\operadriver_win64_2.36.exe'
# Opera browser
_operaInstDir = r'C:\Program Files\Opera\\'
listOperaDir = listdir(_operaInstDir)
listOperaVer = [
char for char in listOperaDir
if char[0].isdigit() and char[-1].isdigit()
]
# listOperaVer.sort(key=lambda version: [int(ver) for ver in version.split('.')])
listOperaVer.sort()
_operacurrentversion = listOperaVer[-1]
_operaExeLoc = _operaInstDir + _operacurrentversion + r'\opera.exe'
_operaCaps = operacapabilities.DesiredCapabilities.OPERA.copy()
_operaOpts = operaoptions.ChromeOptions()
_operaOpts._binary_location = _operaExeLoc
# driver = webdriver.Chrome(executable_path = _operaDriverLoc, chrome_options = _operaOpts, desired_capabilities = _operaCaps)
driver = webdriver.Opera(executable_path=_operaDriverLoc,
options=_operaOpts,
desired_capabilities=_operaCaps)
driver_name = 'opera'
driver_version = _operacurrentversion
elif self.browser == "firefox" or self.browser == "ff":
driver = webdriver.Firefox()
# strver = 'browserVersion'
elif self.browser == "headless" or self.browser == "nobrowser" or self.browser == "virtual":
# This is for running without open Browser UI display - good for Jenkins
chromedriverpath = r'C:\tools\python3\Scripts\chromedriver.exe'
chrome_options = webdriver.ChromeOptions()
# chrome_options.add_argument('--disable-extensions')
chrome_options.add_argument("--incognito")
# chrome_options.add_argument("--disable-plugins-discovery")
# chrome_options.add_argument("--start-maximized")
chrome_options.add_argument('--headless')
chrome_options.add_argument("--proxy-server='direct://'")
chrome_options.add_argument("--proxy-bypass-list=*")
driver = webdriver.Chrome(chromedriverpath, options=chrome_options)
else:
# Set chrome driver
# self.browser == "chrome":
chromedriverpath = r'C:\tools\python3\Scripts\chromedriver.exe'
#os.environ["webdriver.chrome.driver"] = chromedriverpath
chrome_options = webdriver.ChromeOptions()
# chrome_options.add_argument('--disable-extensions')
#chrome_options.add_argument('--profile-directory=Default')
chrome_options.add_argument("--incognito")
# chrome_options.add_argument("--disable-plugins-discovery")
# chrome_options.add_argument("--start-maximized")
driver = webdriver.Chrome(chromedriverpath, options=chrome_options)
#driver.set_window_size(1440, 900)
# dah jadikan default browser = chrome
# else:
# driver = webdriver.Firefox()
# strver = 'browserVersion'
# Setting Driver Implicit Time out for An Element
driver.implicitly_wait(10)
# Maximize the window
if driver.name == 'chrome' and driver_name == 'unknown':
driver.maximize_window()
# Loading browser with App URL
driver.get(baseURL)
if driver_name != 'unknown':
print('Browser version ( ' + str(driver_name) + ' ) = ' +
str(driver_version))
else:
print('Browser version ( ' + driver.name + ' ) = ' +
driver.capabilities[strver])
return driver
