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 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():
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 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 __init__(self, headless=False, executable_path='chromedriver'):
if 'chromedriver' in executable_path:
chrome_options = Options()
chrome_options.add_argument('--enable-javascript')
chrome_options.add_argument('--window-size=1440,900')
chrome_options.add_argument("--disable-extensions")
chrome_options.add_argument("--proxy-server='direct://'")
chrome_options.add_argument("--proxy-bypass-list=*")
chrome_options.add_argument("--start-maximized")
chrome_options.add_argument('--disable-dev-shm-usage')
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--ignore-certificate-errors')
if headless:
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
self.driver = webdriver.Chrome(executable_path=executable_path,
options=chrome_options)
elif 'msedgedriver' in executable_path:
edge_options = EdgeOptions()
edge_options.use_chromium = True
edge_options.add_argument('enable-javascript')
edge_options.add_argument('window-size=1440,900')
edge_options.add_argument("disable-extensions")
edge_options.add_argument("proxy-server='direct://'")
edge_options.add_argument("proxy-bypass-list=*")
edge_options.add_argument("start-maximized")
edge_options.add_argument('disable-dev-shm-usage')
edge_options.add_argument('no-sandbox')
edge_options.add_argument('ignore-certificate-errors')
if headless:
edge_options.add_argument('headless')
edge_options.add_argument('disable-gpu')
self.driver = Edge(executable_path=executable_path,
options=edge_options)
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 _set_options_(self):
edge_options = EdgeOptions()
edge_options.use_chromium = True # if we miss this line, we can't make Edge headless
# A little different from Chrome cause we don't need two lines before 'headless' and 'disable-gpu'
edge_options.add_argument('headless')
edge_options.add_argument('disable-gpu')
return edge_options
def __init__(self,
options=None,
user_agent=None,
wait_time=2,
fullscreen=False,
incognito=False,
headless=False,
chromium=True,
**kwargs):
options = Options() or options
if user_agent is not None:
options.add_argument("--user-agent=" + user_agent)
if incognito:
options.add_argument("--incognito")
if fullscreen:
options.add_argument("--kiosk")
if headless:
options.add_argument("--headless")
options.add_argument("--disable-gpu")
options.use_chromium = chromium
driver = Edge(options=options, **kwargs)
super(WebDriver, self).__init__(driver, wait_time)
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 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 init_browser():
global browser
if "chrome_type" in config and config['chrome_type'] == "msedge":
chrome_options = EdgeOptions()
chrome_options.use_chromium = True
else:
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--ignore-certificate-errors')
chrome_options.add_argument('--ignore-ssl-errors')
chrome_options.add_argument('--use-fake-ui-for-media-stream')
chrome_options.add_experimental_option(
'prefs', {
'credentials_enable_service': False,
'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,
'profile': {
'password_manager_enabled': False
}
})
chrome_options.add_argument('--no-sandbox')
chrome_options.add_experimental_option('excludeSwitches',
['enable-automation'])
if 'headless' in config and config['headless']:
chrome_options.add_argument('--headless')
print("Enabled headless mode")
if 'mute_audio' in config and config['mute_audio']:
chrome_options.add_argument("--mute-audio")
if 'chrome_type' in config:
if config['chrome_type'] == "chromium":
browser = webdriver.Chrome(
ChromeDriverManager(chrome_type=ChromeType.CHROMIUM).install(),
options=chrome_options)
elif config['chrome_type'] == "msedge":
browser = Edge(EdgeChromiumDriverManager().install(),
options=chrome_options)
else:
browser = webdriver.Chrome(ChromeDriverManager().install(),
options=chrome_options)
else:
browser = webdriver.Chrome(ChromeDriverManager().install(),
options=chrome_options)
# make the window a minimum width to show the meetings menu
window_size = browser.get_window_size()
if window_size['width'] < 1200:
print("Resized window width")
browser.set_window_size(1200, window_size['height'])
if window_size['height'] < 850:
print("Resized window height")
browser.set_window_size(window_size['width'], 850)
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 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 browser_with_options(browser):
if browser == 'firefox':
browser_options = webdriver.FirefoxOptions()
elif browser == 'edge':
browser_options = EdgeOptions()
else:
browser_options = webdriver.ChromeOptions()
if browser == 'edge':
browser_options.use_chromium = True
# browser_options.add_argument("no-sandbox")
browser_options.add_argument("window-size=1420,1080")
browser_options.add_argument("headless")
browser_options.add_argument("disable-gpu")
else:
browser_options.add_argument('--no-sandbox')
browser_options.add_argument('--window-size=1420,1080')
browser_options.add_argument('--headless')
browser_options.add_argument('--disable-gpu')
if browser == 'firefox':
driver = webdriver.Firefox(firefox_options=browser_options)
elif browser == 'edge':
driver = Edge(options=browser_options)
else:
driver = webdriver.Chrome(chrome_options=browser_options)
return driver
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 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 setUpClass(cls):
for db in settings.DATABASES:
# Avoid leaking persistent connections
settings.DATABASES[db]["CONN_MAX_AGE"] = 0
os.environ["FREPPLE_TEST"] = "YES"
super().setUpClass()
if settings.SELENIUM_TESTS == "firefox":
firefox_options = webdriver.FirefoxOptions()
if settings.SELENIUM_HEADLESS:
firefox_options.add_argument("--headless")
cls.driver = webdriver.Firefox(firefox_options=firefox_options)
elif settings.SELENIUM_TESTS == "chrome":
options = webdriver.ChromeOptions()
options.add_argument("--silent")
if settings.SELENIUM_HEADLESS:
options.add_argument("--headless")
cls.driver = webdriver.Chrome(chrome_options=options)
elif settings.SELENIUM_TESTS == "edge":
from msedge.selenium_tools import Edge, EdgeOptions
options = EdgeOptions()
options.use_chromium = True
options.add_argument("--silent")
if settings.SELENIUM_HEADLESS:
options.add_argument("--headless")
cls.driver = Edge(options=options)
else:
raise Exception("Invalid setting SELENIUM_TESTS")
cls.driver.set_window_size(1080, 800)
cls.driver.implicitly_wait(10)
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 driver_init():
options = EdgeOptions()
options.use_chromium = True
profile_dir = r"--user-data-dir=C:\Users\Chan\AppData\Local\Microsoft\Edge\User Data"
options.add_argument(profile_dir)
options.add_experimental_option('excludeSwitches', ['enable-logging'])
driver = Edge(options=options)
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 get_headless_edge_options(self):
"Setting up headless edge options"
options = EdgeOptions()
options.use_chromium = True
options.add_argument("headless")
options.add_argument("disable-gpu")
local_driver = Edge(options=options)
return local_driver
def __init__(self, url: str):
edge_options = EdgeOptions()
edge_options.use_chromium = True
edge_options.add_argument('headless')
edge_options.add_argument('disable-gpu')
self.driver = Edge(executable_path='msedgedriver.exe',
options=edge_options)
self.driver.get(url)
self.wait = WebDriverWait(self.driver, 10)
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 run():
email = read_decrypt(efile)
password = read_decrypt(pfile)
cemail = str(email)
cpassword = str(password)
print(cemail)
print(cpassword)
with open("browserdetails.txt", "r") as f:
data = [line.rstrip('\n') for line in f]
browser = data[0].lower()
gpu = data[1].lower()
if browser == 'edge':
try:
requests.get("http://www.google.com")
print('Connection Found')
options = EdgeOptions()
options.use_chromium = True
options.add_argument("--start-maximized")
if gpu == 'no':
options.add_argument("window-size=1920,1080")
options.add_argument("--headless")
options.add_argument("disable-gpu")
options.add_argument("-inprivate")
driver = Edge(executable_path='msedgedriver.exe', options=options)
driver.get('https://gokano.com/')
try:
email = WebDriverWait(driver, 3).until(
EC.presence_of_element_located((By.NAME, 'email')))
print("Page is ready!")
email.send_keys(cemail)
password = driver.find_element_by_name('password')
password.send_keys(cpassword)
time.sleep(3)
button = driver.find_element_by_class_name('submit')
button.click()
print('Login sucessful')
except TimeoutException:
print("Error logining in") #[email protected]
time.sleep(3)
driver.quit()
time.sleep(3)
try:
cdp = driver.find_element_by_link_text('Collect daily points')
cdp.click()
write_time()
time.sleep(3)
driver.quit()
except NoSuchElementException:
print('Already collected')
time.sleep(3)
driver.quit()
print('Automation completed')
time.sleep(3)
driver.quit()
except requests.ConnectionError:
print('Could not connect')
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 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")
