def setup(browser):
if browser == 'chromeheadless':
from selenium.webdriver.chrome.options import Options
chromeoptions = Options()
chromeoptions.headless = True
driver = webdriver.Chrome(options=chromeoptions)
elif browser == 'ffheadless':
from selenium.webdriver.firefox.options import Options
ffoptions = Options()
ffoptions.headless = True
driver = webdriver.Firefox(options=ffoptions)
elif browser == 'edgeheadless':
from msedge.selenium_tools import Edge, EdgeOptions
options = EdgeOptions()
options.use_chromium = True
options.add_argument("--headless")
driver = Edge(options=options)
# elif browser == 'vivaldi':
# opt = Options()
# opt.binary_location = r'C:\Users\Dana Scully\AppData\Local\Vivaldi\Application\vivaldi.exe'
# driver = webdriver.Chrome(options=opt)
#cant get to work
else: #default
driver = webdriver.Chrome()
return driver
def init_driver_edge_windows():
edge_options = EdgeOptions()
edge_options.use_chromium = True
#edge_options.add_argument('headless')
#edge_options.add_argument('disable-gpu')
try:
return Edge(executable_path=r"./driver/msedgedriver",
options=edge_options)
except:
if os.path.isdir("driver"):
subprocess.call(["rd" "/s" "/q", "driver"], shell=True)
os.mkdir("driver")
try:
keyPath = r"Software\Microsoft\Edge\BLBeacon"
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, keyPath, 0,
winreg.KEY_READ)
edge_version = winreg.QueryValueEx(key, "version")[0]
OS = "64" if 'PROGRAMFILES(X86)' in os.environ else "32"
subprocess.call([
"curl", "-o", "tmp.zip",
f"https://msedgedriver.azureedge.net/{edge_version}/edgedriver_win{OS}.zip"
])
subprocess.call(["tar", "-xf", "tmp.zip"])
subprocess.call(["del", "tmp.zip"], shell=True)
subprocess.call(["move", "msedgedriver.exe", "driver"], shell=True)
subprocess.call(["rd" "/s" "/q", "Driver_Notes"], shell=True)
return Edge(executable_path=r".\driver\msedgedriver.exe",
options=edge_options)
except:
os.rmdir("driver")
raise NotImplementedError(
'Une erreur a été rencontrée. Cela peut avoir été causé par une version de Edge obsolète. Mettez le navigateur à jour.'
)
def test_webview_options_to_capabilities(self):
options = EdgeOptions()
options.use_chromium = True
options.use_webview = True
cap = options.to_capabilities()
self.assertEqual('webview2', cap['browserName'])
def __init__(self, username, password, sleep_time=2):
self.username = username
self.password = password
self.sleep_time = sleep_time
options = EdgeOptions()
options.use_chromium = True
self.driver = Edge(options=options)
def Restart_Modem():
options = EdgeOptions()
options.use_chromium = True
options.add_argument("-inprivate")
edge_browser = Edge(options=options)
edge_browser.get('http://192.168.0.1')
time.sleep(2)
print('Welcome')
try:
login = edge_browser.find_element_by_name('username')
password = edge_browser.find_element_by_name('password')
sign = edge_browser.find_element_by_class_name('styled_button_s')
login.clear()
password.clear()
login.send_keys('admin')
password.send_keys('admin')
time.sleep(2)
sign.click()
print('Sign in')
alert = Alert(edge_browser)
time.sleep(2)
edge_browser.get('http://192.168.0.1/saveconf.htm')
time.sleep(2)
system = edge_browser.find_element_by_id('three_level_menu1')
system.click()
time.sleep(2)
reboot = edge_browser.find_element_by_name('reboot')
reboot.click()
alert.accept()
time.sleep(70)
print('Reboot')
edge_browser.quit()
except:
print('Problem with restarting modem')
edge_browser.quit()
def SetUpEdge(self):
"""Product name: Microsoft WebDriver Product version 83.0.478.58
* Edge gets wordy when it's headless, but at least it's working (by setting window size)
* At the time of this refactor for Selenium 4, Edge does not yet support the new API, so I'm using the legacy one"""
options = EdgeOptions()
options.use_chromium = True
#EdgeOptions.AddArguments("headless") # this version of selenium doesn't have addarguments for edge
options.headless = True # I got this to work by setting the handler window size
try:
handler = Edge(executable_path=Path(self.handler_path +
'msedgedriver.exe'),
options=options)
handler.set_window_size(
1600, 1200
) # set the browser handler window size so that headless will work with sendkeys
logging.info(
f"{datetime.now(tz=None)} Info {self.browse} browser handler found"
)
except (WebDriverException):
logging.info(
f"{datetime.now(tz=None)} Warning {self.browse} browser handler not found or failed to launch."
)
handler = None
return handler # ignore the handshake errors
def main():
edge_options = EdgeOptions()
edge_options.use_chromium = True
edge_driver = Edge(options=edge_options)
edge_driver.minimize_window()
# Connect to MySQL database
try:
db = MySQLdb.connect("localhost", "root", "toodles!?13", "player_game")
except Exception as e:
Popen(args="D:\\Programming Projects\\PersonalProjects\\RLCSChampionClassifier\\StartMySQL-C.bat")
db = MySQLdb.connect("localhost", "root", "toodles!?13", "player_game")
time.sleep(7)
# Retrieve players and populate database
player_dict = retrieve_player_data(edge_driver)
player_dict["Unavailable"] = Player("Unavailable", -1)
players = list(player_dict.values())
# for player in players:
# player.to_database(db)
season_list = retrieve_season_data(edge_driver, player_dict)
for season in season_list:
print(season.title)
print("-------------------------------")
for team in season.team_set:
print(team)
print("-------------------------------")
season.to_database(db)
def get_driver(browser, headless_mode=False) -> EventFiringWebDriver:
if browser == "chrome":
options = webdriver.ChromeOptions()
options.add_argument("start-maximized")
if headless_mode is True:
options.add_argument("--headless")
driver = EventFiringWebDriver(
webdriver.Chrome(ChromeDriverManager().install(),
options=options), WebDriverListener())
return driver
elif browser == "firefox":
options = webdriver.FirefoxOptions()
if headless_mode is True:
options.headless = True
driver = EventFiringWebDriver(
webdriver.Firefox(
executable_path=GeckoDriverManager().install(),
options=options), WebDriverListener())
return driver
elif browser == "edge":
options = EdgeOptions()
options.use_chromium = True
if headless_mode is True:
options.headless = True
driver_path = EdgeChromiumDriverManager().install()
driver = EventFiringWebDriver(
Edge(executable_path=driver_path, options=options),
WebDriverListener())
return driver
raise Exception("Provide valid driver name")
def main(driver: WebDriver = None):
try:
if not driver:
options = EdgeOptions()
options.use_chromium = True
options.add_argument("-inprivate")
driver = Edge(executable_path=EDGE_DRIVER_PATH, options=options)
driver.get(url_encode())
wait = WebDriverWait(driver, 30, 1)
# elem_vote = driver.find_element(By.XPATH, "//a[text()='投票']")
# elem_vote = wait.until(EC.presence_of_element_located((By.XPATH, r"//a[text()='投票']")))
# elem_vote.click()
callback = step()
elem = wait.until(callback)
# elem_vote_options = wait.until(get_elem_vote_options)
# elem_vote_options = wait.until(EC.visibility_of_all_elements_located((By.XPATH, "//div/div/label[@class='label']")))
# elem_vote_options = elem_vote.find_elements(By.XPATH, "//div/div/label[@class='label']")
elem = wait.until(callback)
# map(lambda e: e.click(), elem_vote_options)
# elem_vote_btn = wait.until(EC.element_to_be_clickable((By.XPATH, r"//a[text()='確認送出']")))
# 1elem_vote_btn = driver.find_element(By.XPATH, r"//a[text()='確認送出']")
# elem_vote_btn.click()
elem = wait.until(callback)
except Exception as e:
traceback.print_exc(4, sys.stderr)
finally:
driver.delete_all_cookies()
driver.refresh()
main(driver)
driver.quit()
def edge(headless=True):
options = EdgeOptions()
options.use_chromium = True
options.headless = headless
edge_driver = EdgeChromiumDriverManager().install()
driver = Edge(edge_driver, options=options)
return driver
def main(position, location):
"""Run the main program routine"""
scraped_jobs = []
scraped_urls = set()
url = get_url(position, location)
# setup web driver
options = EdgeOptions()
options.use_chromium = True
driver = Edge(options=options)
driver.implicitly_wait(5)
driver.get(url)
# extract the job data
while True:
cards = driver.find_elements_by_class_name('jobsearch-SerpJobCard')
get_page_records(cards, scraped_jobs, scraped_urls)
try:
driver.find_element_by_xpath('//a[@aria-label="Next"]').click()
except NoSuchElementException:
break
except ElementNotInteractableException:
driver.find_element_by_id('popover-x').click() # to handle job notification popup
get_page_records(cards, scraped_jobs, scraped_urls)
continue
# shutdown driver and save file
driver.quit()
save_data_to_file(scraped_jobs)
def edge_builder(headless=False, **kwargs):
edge_options = EdgeOptions()
edge_options.use_chromium = True
if headless:
edge_options.headless = True
service_log_path = f"{LOG_DIR}/edge_driver.log"
driver = webdriver.Edge(edge_options, service_log_path=service_log_path)
return driver
def __init__(self):
options = EdgeOptions()
options.use_chromium = True
# options.add_argument("headless")
# options.add_argument("disable-gpu")
#防止打印无用信息 enable-automation规避检测
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging'])
self.bro = Edge(options = options)
def getRobertsAnimeCornerStoreData(title, bookType):
#Starts wevdriver to scrape edge chromium
options = EdgeOptions()
options.use_chromium = True
options.add_argument("-inprivate")
options.add_argument("--headless")
driver = Edge(options=options)
soup = BeautifulSoup(driver.page_source, "html.parser")
newPage = getDataPage(driver, title, soup, bookType)
if not newPage:
print(title)
print("Error!!!!! Invalid Series Title")
return
else:
#Start scraping the URL where the data is found
driver.get(newPage)
#Wait for the web page to finish loading
time.sleep(5)
#Start parsing the web pages html and css
soup2 = BeautifulSoup(driver.page_source, "html.parser")
#Get the Title and Price of each manga or light novel
dataList, titleList = [], []
titleParse = soup2.find_all(
"tr", {"valign": "top"
})[1:] #Remove first element cause it pulls unwanted text
priceList = soup2.select(
'font[color="#ffcc33"]'
)[1::
2] #[1::2] to remove the RACS Price text (every odd element in the list)
#Convert title list to strings so you can remove any black/empyt spaces
for bookTitle in titleParse:
seriesTitle = bookTitle.find("font", {"size": "2"}).b.text
if seriesTitle != " ":
titleList.append(seriesTitle)
del titleParse #Remove list from memory as we don't need it anymore
stockStatus = ""
for titles, prices in zip(titleList, priceList):
specTitle = str(titles).replace(",", "")
if specTitle.find("Pre Order") != -1:
stockStatus = "Pre-Order"
else:
stockStatus = "Available"
dataList.append([specTitle, prices.text, stockStatus])
csvFile = "AnimeCornerStore.csv"
with open(csvFile, "w", newline="", encoding="utf-8") as file:
writeToFile = csv.writer(file)
writeToFile.writerow(["Title", "Price", "Stock Status"])
writeToFile.writerows(dataList)
#TableGUI.robertsDataTable.setItem(numRows, 0, QtWidgets.QTableWidgetItem(str(dataList[0])))
return dataList
def create(downloadPath):
driverPath = os.path.dirname(
os.path.realpath(__file__)) + "\\msedgedriver.exe"
edgeOptions = EdgeOptions()
prefs = {"download.default_directory": os.getcwd() + "\\" + downloadPath}
edgeOptions.add_experimental_option("prefs", prefs)
return Edge(executable_path=driverPath, options=edgeOptions)
def codigo(link, navegador):
cont = 0
x = 1
y = 1
split = link.split('q=')
print(split)
print(navegador)
if navegador == 2:
options = EdgeOptions()
options.use_chromium = True
driver = Edge(options=options)
driver.maximize_window()
#print(link)
driver.get("https://scholar.google.com.br/scholar?start=0&q={}".format(
split[1]))
root = os.getcwd()
wait = WebDriverWait(driver, 10)
while (True):
try:
os.mkdir('planilhas')
except FileExistsError:
os.chdir(f'{root}\\planilhas')
wb = Workbook()
planilha = wb.worksheets[0]
items = wait.until(
EC.visibility_of_all_elements_located(
(By.CSS_SELECTOR, '.gs_rt a')))
for item in items:
nome_artigo = item.text
link_artigo = item.get_attribute('href')
print('Artigo: ', nome_artigo, '\nLink: ', link_artigo,
'\n')
planilha['A{}'.format(x)] = nome_artigo
planilha['B{}'.format(y)] = link_artigo
botao = driver.find_element_by_partial_link_text('Mais')
botao.click()
wb.save("planilha.xlsx")
x += 1
y += 1
return
def openEdgeBrowser(webDriverLocation: str, showBrowser: bool) -> webdriver:
print("打开Edge浏览器！")
option = EdgeOptions()
# 开启无头模式.
if not showBrowser:
option.use_chromium = True
option.headless = True
browser = Edge(executable_path=webDriverLocation, options=option)
return browser
def open_browser(env, browser='chrome', incognito=True):
driver = None
if browser == "chrome":
chrome_options = webdriver.ChromeOptions()
if incognito:
chrome_options.add_argument('--incognito')
driver = webdriver.Chrome(executable_path=chrome_driver_path, chrome_options=chrome_options)
elif browser == "msedge":
edge_options = EdgeOptions()
edge_options.use_chromium = True
if incognito:
edge_options.add_argument('-inprivate')
driver = Edge(executable_path=msedge_driver_path, options=edge_options)
elif browser == "firefox":
firefox_options = webdriver.FirefoxOptions()
if incognito:
firefox_options.add_argument('--incognito')
driver = webdriver.Firefox(executable_path=firefox_driver_path, options=firefox_options)
elif browser == "ie":
driver = webdriver.Ie(executable_path=ie_driver_path)
# selenium grid
# driver = webdriver.Remote(command_executor='http://10.22.40.234:5555/wd/hub',
# desired_capabilities=DesiredCapabilities.INTERNETEXPLORER)
elif browser == "safari":
driver = webdriver.Safari()
# 获取web配置
with open(web_config_path, 'r', encoding='utf-8') as file:
data = yaml.load(file, Loader=yaml.FullLoader)
# 以下是一个示例，基于config/web_config.yaml文件做的配置
if env == "msit":
url = data["portal"]['msit']
Logger.info("Open Url: %s", url)
driver.get(url)
if env == "srol1":
url = data["portal"]['srol1']
Logger.info("Open Url: %s", url)
driver.get(url)
if env == "srol2":
url = data["portal"]['srol2']
Logger.info("Open Url: %s", url)
driver.get(url)
if env == "ppe":
url = data["portal"]['ppe']
Logger.info("Open Url: %s", url)
driver.get(url)
if env == "refe":
url = data["portal"]['refe']
Logger.info("Open Url: %s", url)
driver.get(url)
elif env == '':
driver = None
driver.maximize_window()
driver.implicitly_wait(data['implicitly_wait'])
return driver
def create_chrome_driver(self):
chrome_options = EdgeOptions()
proxy = self.get_next_proxy()
print("CurrProxy: " + proxy)
chrome_options.add_argument('--proxy-server=%s' % proxy)
return webdriver.Chrome(
"C:\\Windows.old\\Users\\Public\\chromedriver.exe",
options=chrome_options)
def test_legacy_options_to_capabilities(self):
options = EdgeOptions()
options._page_load_strategy = 'eager' # common
options._debugger_address = 'localhost:9222' # chromium only
cap = options.to_capabilities()
self.assertEqual('MicrosoftEdge', cap['browserName'])
self.assertEqual('eager', cap['pageLoadStrategy'])
self.assertFalse('ms:edgeOptions' in cap)
self.assertFalse(cap['ms:edgeChromium'])
def test_chromium_driver_with_chromium_options(self):
options = EdgeOptions()
options.use_chromium = True
try:
driver = Edge('msedgedriver.exe', options=options)
except:
self.assertTrue(
False, 'Test chromium driver with chromium options failed.')
else:
driver.quit()
def setUp(self):
options = EdgeOptions()
options.use_chromium = True
options.binary_location = "C:\\Program Files (x86)\\Microsoft\\Edge Dev\\Application\\msedge.exe"
dir = os.path.dirname(os.path.realpath(__file__))
edge_driver_path = dir + "\\edgedriver_win64\\msedgedriver.exe"
self.driver = Edge(options=options, executable_path=edge_driver_path)
self.driver.implicitly_wait(30)
self.driver.maximize_window()
self.driver.get("http://localhost:4200")
def __init__(self,
df_dir='src/data',
df_path='data/dataframe.csv',
df_file_name='new_dataframe.csv',
cookies_path='src/cookies/cookies.pkl',
driver_path='',
_driver=None,
_check=False):
self.df_dir = df_dir
self.df_path = df_path if self.read_file is None else f'data/{self.read_file}'
self.df_file_name = df_file_name
self.cookies_path = cookies_path
self.driver_path = driver_path
self.driver = _driver
self.check = _check
if self.driver is None:
# Selenium capabilities and other settings
options = Options()
# Options for microsoft edge (chromium)
edge_options = EdgeOptions()
edge_options.use_chromium = True
edge_options.add_argument('log-level=3')
edge_options.add_argument('lang=en')
edge_options.add_argument('--start-maximized')
# Main webdriver
self.driver = Edge(executable_path=self.driver_path,
options=edge_options)
self._check_connection()
def createMSEdgeDriver():
# goog:loggingPrefs allows for access to console logs.
desiredCapabilities = DesiredCapabilities.CHROME
desiredCapabilities['goog:loggingPrefs'] = { 'browser':'ALL' }
msedge_options = EdgeOptions()
msedge_options.use_chromium = True
driver = Edge(options = msedge_options)
return driver
def __init__(self):
'''Initialize the application'''
#As using the standard webdriver was giving warnings and messing up the terminal, I used the code below to show just what I want.
self.opt = EdgeOptions()
self.opt.add_experimental_option('excludeSwitches', ['enable-logging'])
self.opt.add_argument("--start-maximized")
self.opt.use_chromium = True
self.driver = Edge(
executable_path=
r"C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedgedriver.exe",
options=self.opt)
def main():
"""Get what?"""
options = EdgeOptions()
options.use_chromium = True
# options.add_argument("headless")
# options.add_argument("disable-gpu")
driver = Edge(options=options)
# url = 'https://www.flipkart.com/laptops-store'
url = 'https://podbay.fm/p/sach-noi-danh-cho-ban/'
driver.get(url)
# driver.execute_script("window.scrollTo(0,document.body.scrollHeight)")
el = driver.find_element_by_tag_name('body')
# el = driver.find_element(By.NAME, "Loading more").send_keys()
for i in range(4):
el.send_keys("webdriver" + Keys.END)
sleep(3)
# driver.close()
# print(driver.title)
# products = [] # List to store name of products
# prices = [] # List to store price of product
# ratings = [] # List to store ratings of product
titles = []
urls = []
content = driver.page_source
# soup = BeautifulSoup(content, 'html.parser')
soup = BeautifulSoup(content, 'lxml')
for a in soup.findAll('a', href=True, attrs={'class': 'jsx-1043497740'}):
# for a in soup.findAll('a', href=True, attrs={'class': 'download'}):
# name = a.find('div', attrs={'class': 's1Q9rs'})
# price = a.find('div', attrs={'class': '_30jeq3'})
# rating = a.find('div', attrs={'class': '_3LWZlK'})
# products.append(name.text)
# prices.append(price.text)
# ratings.append(rating.text)
# print(a)
title = a.string
if title != None:
print(title)
titles.append(title)
link = a.get('href')
if link.endswith(".mp3"):
print(link)
urls.append(link)
driver.close()
print(titles)
print(urls)
def setUp(self):
WebDriverFactory().setup_edgedriver()
from msedge.selenium_tools import Edge, EdgeOptions
options = EdgeOptions()
options.use_chromium = True
options.set_capability('platform', 'MAC' if OS_NAME == 'MAC' else 'WINDOWS')
self.driver1 = Edge(options=options)
self.driver2 = Edge(options=options)
self.driver1.maximize_window()
self.wait1 = WebDriverWait(self.driver1, 5)
self.wait2 = WebDriverWait(self.driver2, 5)
def test_legacy_options(self):
try:
options = EdgeOptions()
options.use_chromium = False
driver = Edge(options=options)
cap = driver.capabilities
self.assertEqual('MicrosoftEdge', cap['browserName'],
'Driver launches Edge Legacy.')
except:
self.assertTrue(False, 'Test legacy options failed.')
else:
driver.quit()
def init_browser_driver(browser_name, driver_path):
if browser_name == 'Edge':
# driver_path = r'C:\lib\edgedriver_win64\msedgedriver.exe'
options = EdgeOptions()
options.use_chromium = True
return Edge(options=options, executable_path=driver_path)
elif browser_name == 'Chrome':
# driver_path = r'C:\lib\chromedriver_win32\chromedriver.exe'
return Chrome(executable_path=driver_path)
else:
sys.exit(
'Implement the browser driver initialization of your choice here.')
def accesotfs(self, ruta, dire):
# self.robot = robot
ticket1 = str(self.dato1.get())
#self.chrome_options = Options()
#if self.seleccion.get()==1:
#self.chrome_options.add_argument("--headless")
# self.driver = webdriver.Chrome(executable_path=r"C:\Google\chromedriver")
# self.driver = webdriver.Edge(executable_path=r"C:\Google\msedgedriver")
self.edge_option = EdgeOptions()
self.edge_option.add_argument("hide_console")
# options.add_argument = ["hide_console"]
# self.driver = webdriver.Edge(options)
# self.driver = webdriver.Edge("C:\Google\msedgedriver", options=self.edge_option)
self.driver = Edge("C:\Google\msedgedriver", service_args= ["hide_console"])
url = "http://10.1.27.11:8080/tfs/TFSYPF/E2E/_workitems?_a=edit&id="
urlarmada = url + ticket1
# Conectarse
self.driver.get(urlarmada)
self.driver.implicitly_wait(8)
# self.robot.typewrite("SE33439")
# time.sleep(1)
# self.robot.press('tab')
# time.sleep(1)
# robot.typewrite("Homeroibm2020-")
# time.sleep(1)
# self.robot.press('tab')
# time.sleep(1)
# self.robot.press('enter')
# time.sleep(4)
# dirigirse hacia el modulo attachment
self.attachment = "ui-id-7"
self.driver.find_element_by_id(self.attachment).click()
# boton agregar adjuntos
# time.sleep(1)
self.driver.implicitly_wait(5)
for i in ruta:
nombre_archivo = i
direarchivo= dire + nombre_archivo
self.driver.find_element_by_xpath("/html/body/div[2]/div/div[2]/div/div[2]/div/div[3]/div[4]/div[2]/div/div[2]/div[2]/table/tbody/tr[5]/td/table/tbody/tr/td[2]/table/tbody/tr/td/div/div[3]/table/tbody/tr/td/div/ul/li[2]").click()
# time.sleep(1)
# boton seleccionar archivo
self.driver.implicitly_wait(5)
self.driver.find_element_by_xpath("/html/body/div[4]/div[2]/div/form/input[1]").send_keys(direarchivo)
# time.sleep(1)
# boton aceptar
self.driver.implicitly_wait(5)
self.driver.find_element_by_xpath("/html/body/div[4]/div[3]/div/button[1]").click()
# time.sleep(1)
# boton guardar
self.driver.implicitly_wait(5)
self.driver.implicitly_wait(5)
self.driver.find_element_by_xpath("/html/body/div[2]/div/div[2]/div/div[2]/div/div[3]/div[4]/div[2]/div/div[2]/div[1]/ul/li[2]").click()
