def __init__(self, q, profile_dir=None):
self.lr = LRequests()
self.gsa = GsaCaptcha()
self.key_asins = {}
self.q = q
# options = webdriver.ChromeOptions()
options = uc.ChromeOptions()
if profile_dir is not None:
options.add_argument('--user-data-dir=%s' % profile_dir)
prefs = {}
# prefs["profile.default_content_settings"] = {"images": 2}
# prefs["profile.managed_default_content_settings"] = {"images": 2}
# prefs["intl.accept_languages"] = 'en,en_US'
# options.add_experimental_option("prefs", prefs)
# options.add_argument('--start-maximized')
options.add_argument('--blink-settings=imagesEnabled=false')
options.add_argument('--lang=en')
# self.browser = webdriver.Chrome(options=options)
self.browser = uc.Chrome(options=options, driver_executable_path=os.path.join(os.getcwd(), 'chromedriver.exe'), use_subprocess=True)
self.wait = WebDriverWait(self.browser, 120)
async def scrap_page(
url: HttpUrl,
window_size: WindowSize,
wait_before_scroll: int,
wait_after_scroll: int,
) -> Tuple[PageMetrics, PageType]:
chrome_options = uc.ChromeOptions()
chrome_options.headless = True
chrome_options.add_argument("--headless")
chrome_options.add_argument(f"--window-size={window_size}")
capbs = DesiredCapabilities.CHROME.copy()
capbs["goog:loggingPrefs"] = {"performance": "ALL"}
driver = uc.Chrome(options=chrome_options, desired_capabilities=capbs)
driver.set_script_timeout(10)
driver.get(url)
driver.implicitly_wait(wait_before_scroll)
try:
driver.execute_script(
"window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' })"
)
except JavascriptException:
pass
driver.implicitly_wait(wait_after_scroll)
page_type = await get_page_type(driver)
page_metrics = await get_page_metrics(driver)
driver.quit()
return page_metrics, page_type
def init_driver():
appState = {
"recentDestinations": [{
"id": "Save as PDF",
"origin": "local",
"account": ""
}],
"selectedDestinationId":
"Save as PDF",
"version":
2
}
download_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
r"output\PDF\"")
profile = {
'printing.print_preview_sticky_settings.appState':
json.dumps(appState),
"directory_upgrade": True,
"download.default_directory":
"C:\\Users\\samy.doreau\\Dropbox\\Code\\Automation\\output\\PDF",
"extensions_to_open": ""
}
chrome_options = webdriver.ChromeOptions()
chrome_options.add_experimental_option('prefs', profile)
chrome_options.add_argument('--kiosk-printing')
driver = uc.Chrome(chrome_options=chrome_options)
return driver
def __init__(self):
try:
ua = UserAgent()
self.user_agent = ua.random
except FakeUserAgentError:
self.user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36"
options = uc.ChromeOptions()
# options.add_argument("--user-agent=" + self.user_agent)
self.bot = uc.Chrome(options=options)
self.bot.delete_all_cookies()
def head_uc(request: FixtureRequest):
request.instance.driver = uc.Chrome()
def teardown():
request.instance.driver.save_screenshot(FAILED_SCREENSHOT_NAME)
request.instance.driver.quit()
request.addfinalizer(teardown)
return request.instance.driver
def __init__(self, credentials, chrome_location, logger, debugging=True):
self.credentials = credentials
self.debugging = debugging
self.logger = logger
self.logged_in = False
options = uc.ChromeOptions()
options.binary_location = chrome_location
self.driver = uc.Chrome(options=options)
async def main():
opts = uc.ChromeOptions()
opts.headless = True
driver = uc.Chrome(options=opts)
streamer = ChromeDriverCV2Streamer(driver)
streamer.start()
for url in just_some_urls:
# with driver:
driver.get("https://nu.nl")
await asyncio.sleep(3)
def main():
with Display(visible=False, size=(1366, 768), backend='xvfb') as _display:
options = uc.ChromeOptions()
options.add_argument('--user-data-dir={}'.format(tempfile.mktemp()))
options.add_argument(
'--no-first-run --no-service-autorun --password-store=basic')
driver = uc.Chrome(version_main=98, options=options)
driver.get('http://javabin.cn/bot/bot.html?headless')
time.sleep(8)
print(driver.find_element_by_tag_name('body').text)
def setup_driver():
"""Setup the firefox geckodriver to be headless.
Returns:
selenium.webdriver.Firefox: The setup geckodriver.
"""
options = uc.ChromeOptions()
# options.headless = True
options.add_argument(
'--no-first-run --no-service-autorun --password-store=basic')
return uc.Chrome(options=options)
def __init__(self):
# # chop = webdriver.ChromeOptions()
# # chop.add_extension(settings.SELENIUM_CHROMEADBLOCK_PATH)
# # self.driver = webdriver.Chrome(settings.SELENIUM_CHROMEDRIVER_PATH, chrome_options=chop) # your chosen driver
# ffprofile = webdriver.FirefoxProfile()
# # ffprofile.add_extension(settings.SELENIUM_GECKOADBLOCK_PATH)
# self.driver = webdriver.Firefox(ffprofile, executable_path=settings.SELENIUM_GECKODRIVER_PATH)
uc.TARGET_VERSION = 95
options = uc.ChromeOptions()
options.add_argument(
'--no-first-run --no-service-autorun --password-store=basic')
self.driver = uc.Chrome(options=options)
def headless_uc(request: FixtureRequest):
options = uc.ChromeOptions()
options.headless = True
request.instance.driver = uc.Chrome(options=options)
def teardown():
request.instance.driver.sapipve_screenshot(FAILED_SCREENSHOT_NAME)
request.instance.driver.quit()
request.addfinalizer(teardown)
return request.instance.driver
def test_quick():
import undetected_chromedriver.v2 as uc
print("uc module: ", uc)
# options = selenium.webdriver.ChromeOptions()
options = uc.ChromeOptions()
options.add_argument("--user-data-dir=c:\\temp")
options.binary_location = uc.find_chrome_executable()
driver = uc.Chrome(
executable_path="./chromedriver.exe",
options=options,
service_log_path="c:\\temp\\service.log.txt",
)
while True:
sys.stdin.read()
def main():
parser = argparse.ArgumentParser(description="Gather files from RSS flow.")
parser.add_argument("url", help="URL to RSS")
args = parser.parse_args()
category_id = RSS_LINK_PATTERN.search(args.url).groups()[0]
LAST_DLED_ID_FOLDER.mkdir(exist_ok=True)
last_dled_id_file = LAST_DLED_ID_FOLDER / category_id
last_dled_id_file.touch()
driver = uc.Chrome()
with driver:
driver.get(args.url)
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
WebDriverWait(driver, 20).until(
EC.presence_of_element_located((By.ID, HTML_DIV_ID)))
soup = BeautifulSoup(driver.page_source)
enclosures = soup.body.div.find_all("enclosure")
urls = [x.get("url") for x in enclosures]
pprint(urls)
content = last_dled_id_file.read_text()
previous_latest_id = int(content or 0)
latest_id = None
with driver:
for index, url in enumerate(urls):
match = DL_LINK_PATTERN.search(url)
current_id = int(match.groups()[0])
if index == 0:
latest_id = int(current_id)
if current_id <= previous_latest_id:
break
driver.get(url)
time.sleep(DOWNLOAD_WAIT + random.randint(0, 10) * 0.1)
if latest_id is not None:
last_dled_id_file.write_text(str(latest_id))
def __init__(self, user, password, keyword, retry):
# 创建一个参数对象，用来控制chrome以无界面模式打开
chrome_options = webdriver.ChromeOptions()
# 禁用GPU加速
chrome_options.add_argument('--disable-gpu')
chrome_options.add_argument('--disable-dev-shm-usage')
self.browser = uc.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.url = 'https://www.zhihu.com/signin'
self.sli = Code()
self.user = user
self.password = password
self.keyword = keyword
self.cookies = {}
# 失败重试次数
self.retry = retry
def __init__(self, list_queue, product_queue, profile_dir=None):
self.list_queue = list_queue
self.product_queue = product_queue
self.gsa = GsaCaptcha()
self.key_asins = {}
options = uc.ChromeOptions()
if profile_dir:
options.add_argument('--user-data-dir=%s' % profile_dir)
# options.add_experimental_option('prefs', {'intl.accept_languages': 'en,en_US'})
# chrome_options = webdriver.ChromeOptions()
# prefs = {"profile.managed_default_content_settings.images": 2}
prefs = {}
prefs["profile.default_content_settings"] = {"images": 2}
prefs["profile.managed_default_content_settings"] = {"images": 2}
options.add_experimental_option("prefs", prefs)
options.add_argument('--start-maximized')
options.add_argument('--blink-settings=imagesEnabled=false')
self.browser = uc.Chrome(options=options)
self.wait = WebDriverWait(self.browser, 120)
def open_web(url="https://youtube.com"):
global driver
try:
shutil.rmtree("log") # 쿠키 / 캐쉬파일 삭제
except FileNotFoundError:
pass
options = uc.ChromeOptions()
# setting profile
# options.user_data_dir = "log"
# another way to set profile is the below (which takes precedence if both variants are used
# options.add_argument('--user-data-dir=log')
# just some options passing in to skip annoying popups
# --password-store=basic --start-maximized
options.add_argument('--no-first-run --no-service-autorun')
driver = uc.Chrome(options=options)
# known url using cloudflare's "under attack mode"
driver.get(url)
print("[INFO] open_web")
time.sleep(3)
def test_undetected_chromedriver():
import undetected_chromedriver.v2 as uc
driver = uc.Chrome()
with driver:
driver.get("https://coinfaucet.eu")
time.sleep(4) # sleep only used for timing of screenshot
driver.save_screenshot("coinfaucet.eu.png")
with driver:
driver.get("https://cia.gov")
time.sleep(4) # sleep only used for timing of screenshot
driver.save_screenshot("cia.gov.png")
with driver:
driver.get("https://lhcdn.botprotect.io")
time.sleep(4) # sleep only used for timing of screenshot
driver.save_screenshot("notprotect.io.png")
with driver:
driver.get("https://www.datadome.co")
time.sleep(4) # sleep only used for timing of screenshot
driver.save_screenshot("datadome.co.png")
import json
import requests
import urllib.parse
PATH = r"C:\chromedriver\90\chromedriver.exe"
opt = webdriver.ChromeOptions()
caps = webdriver.DesiredCapabilities.CHROME.copy()
opt.add_argument("--no-sandbox")
opt.add_argument("--disable-gpu")
opt.add_argument("--allow-running-insecure-content")
opt.add_argument("--ignore-ssl-errors=yes")
opt.add_argument("--window-size=1280,720")
opt.add_argument("--ignore-certificate-errors")
opt.add_argument("--disable-dev-shm-usage")
caps['goog:loggingPrefs'] = {'browser': 'ALL'}
driver = uc.Chrome(PATH, options=opt, desired_capabilities=caps)
#driver = uc.Chrome()
def YouTube_Google_Log_In(thisLogin):
try:
email = 0
password = 0
isFound = True
laccounts = get_Google_Accounts()
if thisLogin != "":
for x in laccounts:
if thisLogin in x:
email = x[0]
password = x[1]
isFound = False
import undetected_chromedriver.v2 as uc
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.action_chains import ActionChains
import time
import csv
import re
import pandas as pd
URL = input("input url:")
Export_File_Name = input("Export_File_Name:")
driver = uc.Chrome()
dict_array = []
def headers_loop():
try:
WebDriverWait(driver, 15).until(EC.element_to_be_clickable((By.XPATH, "//div[contains(@jsaction, 'mouseover:pane')]/a")))
except Exception as e:
print(e)
pass
numbers = driver.find_elements_by_xpath('//div[@class="gm2-caption"]/div/span/span')
length = (int(numbers[1].text)-int(numbers[0].text))+1
for i in range(length):
try:
WebDriverWait(driver, 15).until(EC.element_to_be_clickable((By.XPATH, "//div[contains(@jsaction, 'mouseover:pane')]/a")))
except Exception as e:
print(e)
def DataPull(path):
options = uc.ChromeOptions()
# options.headless=True
# options.add_argument('--headless')
driver = uc.Chrome(options=options)
final_directory = path + '/TestData'
p = {'download.default_directory': final_directory}
final_directory = os.path.join(path, r'TestData')
print(f'Made {final_directory} folder.')
if not os.path.exists(final_directory):
os.makedirs(final_directory)
countries = ("fr", "de", "gr", "jp", "us")
# countries = (
# "ad","ar","au","at","be",
# "bo","br","bg","ca","cl",
# "co","cr","cy","cz","dk",
# "do","ec","sv","ee","fi",
# "fr","de","gr","gt","hn",
# "hk","hu","id","is","ie","it",
# "jp","lv","li","lt","lu","my",
# "mt","mx","mc","nl","nz",
# "ni","no","pa","py","pe",
# "ph","pl","pt","es","sg",
# "sk","se","ch","tw","tr",
# "gb","us","uy")
# all_markets = {
# "AD": "Andorra","AR": "Argentina","AU": "Australia",
# "AT": "Austria",
# "BE": "Belgium",
# "BO": "Bolivia",
# "BR": "Brazil",
# "BG": "Bulgaria",
# "CA": "Canada",
# "CL": "Chile",
# "CO": "Colombia",
# "CR": "Costa Rica",
# "CY": "Cyprus",
# "CZ": "Czech Republic",
# "DK": "Denmark",
# "DO": "Dominican Republic",
# "EC": "Ecuador",
# "SV": "El Salvador",
# "EE": "Estonia",
# "FI": "Finland",
# "FR": "France",
# "DE": "Germany",
# "GR": "Greece",
# "GT": "Guatemala",
# "HN": "Honduras",
# "HK": "Hong Kong",
# "HU": "Hungary",
# "ID": "Indonesia",
# "IS": "Iceland",
# "IE": "Republic of Ireland",
# "IT": "Italy",
# "JP": "Japan",
# "LV": "Latvia",
# "LI": "Liechtenstein",
# "LT": "Lithuania",
# "LU": "Luxembourg",
# "MY": "Malaysia",
# "MT": "Malta",
# "MX": "Mexico",
# "MC": "Monaco",
# "NL": "Netherlands",
# "NZ": "New Zealand",
# "NI": "Nicaragua",
# "NO": "Norway",
# "PA": "Panama",
# "PY": "Paraguay",
# "PE": "Peru",
# "PH": "Philippines",
# "PL": "Poland",
# "PT": "Portugal",
# "ES": "Spain",
# "SG": "Singapore",
# "SK": "Slovakia",
# "SE": "Sweden",
# "CH": "Switzerland",
# "TW": "Taiwan",
# "TR": "Turkey",
# "GB": "United Kingdom",
# "US": "United States",
# "UY": "Uruguay"
# };
for country in countries:
driver.get('https://spotifycharts.com/regional/{}/daily/latest'.format(
country))
try:
l = driver.find_element_by_link_text('DOWNLOAD TO CSV')
set1 = l
set1.click()
except NoSuchElementException:
continue
time.sleep(5)
driver.get(
'https://spotifycharts.com/regional/{}/weekly/latest'.format(
country))
try:
l = driver.find_element_by_link_text('DOWNLOAD TO CSV')
set1 = l
set1.click()
except NoSuchElementException:
continue
time.sleep(5)
timestr = time.strftime("%Y%m%d")
downloads_path = str(Path.home() / "Downloads")
os.chdir(downloads_path)
for file in glob.glob("*daily-latest.csv"):
shutil.move(file, final_directory)
print(f'Moved {file} Files.')
for file in glob.glob("*weekly-latest.csv"):
shutil.move(file, final_directory)
print(f'Moved {file} Files.')
os.chdir(final_directory)
os.rename('regional-{}-daily-latest.csv'.format(country),
"{}_top200_daily_{}.csv".format(country, timestr))
os.rename('regional-{}-weekly-latest.csv'.format(country),
"{}_top_200_weekly_{}.csv".format(country, timestr))
driver.quit()
def __init__(self,
headless=False,
store_session=True,
proxy=None,
user_data=False):
self.email = None
self.may_send_email = False
self.session_data = {
"duration": 0,
"like": 0,
"dislike": 0,
"superlike": 0
}
start_session = time.time()
# this function will run when the session ends
@atexit.register
def cleanup():
# End session duration
seconds = int(time.time() - start_session)
self.session_data["duration"] = seconds
# add session data into a list of messages
lines = []
for key in self.session_data:
message = "{}: {}".format(key, self.session_data[key])
lines.append(message)
# print out the statistics of the session
try:
box = self._get_msg_box(lines=lines, title="Tinderbotz")
print(box)
finally:
print("Started session: {}".format(self.started))
y = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print("Ended session: {}".format(y))
# Go further with the initialisation
# Setting some options of the browser here below
options = uc.ChromeOptions()
# Create empty profile to avoid annoying Mac Popup
if store_session:
if not user_data:
user_data = f"{Path().absolute()}/chrome_profile/"
if not os.path.isdir(user_data):
os.mkdir(user_data)
Path(f'{user_data}First Run').touch()
options.add_argument(f"--user-data-dir={user_data}")
options.add_argument(
'--no-first-run --no-service-autorun --password-store=basic')
options.add_argument("--lang=en-GB")
if headless:
options.headless = True
if proxy:
if '@' in proxy:
parts = proxy.split('@')
user = parts[0].split(':')[0]
pwd = parts[0].split(':')[1]
host = parts[1].split(':')[0]
port = parts[1].split(':')[1]
extension = get_proxy_extension(PROXY_HOST=host,
PROXY_PORT=port,
PROXY_USER=user,
PROXY_PASS=pwd)
options.add_extension(extension)
else:
options.add_argument(f'--proxy-server=http://{proxy}')
# Getting the chromedriver from cache or download it from internet
print("Getting ChromeDriver ...")
self.browser = uc.Chrome(
options=options) #ChromeDriverManager().install(),
#self.browser = webdriver.Chrome(options=options)
self.browser.set_window_size(1250, 750)
# clear the console based on the operating system you're using
os.system('cls' if os.name == 'nt' else 'clear')
# Cool banner
print(Printouts.BANNER.value)
time.sleep(1)
self.started = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print("Started session: {}\n\n".format(self.started))
def __init__(self):
self.driver = uc.Chrome()
def by_ticker_command(ticker="", sort="fund_percent", num: int = 15):
"""Display ETF Holdings. [Source: StockAnalysis]"""
# Debug
if imps.DEBUG:
logger.debug("etfs")
options = uc.ChromeOptions()
options.headless = True
options.add_argument("--headless")
options.add_argument("--incognito")
driver = uc.Chrome(options=options, version_main=98)
driver.set_window_size(1920, 1080)
driver.get(f"http://etf.com/stock/{ticker.upper()}/")
time.sleep(2)
driver.find_element(By.XPATH, "(//div[@id='inactiveResult'])[3]").click()
soup5 = bs4.BeautifulSoup(driver.page_source, "html.parser")
r_ticker, r_holdings, r_name, r_market = [], [], [], []
table1 = soup5.find("table", id="StockTable")
table = table1.find("tbody")
for x in table.find_all("tr"):
r_ticker.append(x.find("td").text)
r_name.append(x.find("td").findNext("td").text)
r_holdings.append(
x.find("td").findNext("td").findNext("td").findNext("td").text)
r_market.append(
x.find("td").findNext("td").findNext("td").findNext("td").findNext(
"td").text)
driver.quit()
df = pd.DataFrame({
"Ticker": r_ticker,
"Name": r_name,
"Holdings": r_holdings,
"Market Value": r_market,
})
if df.empty:
raise Exception("No company holdings found!\n")
if sort == "mkt_value":
key = imps.natsort.index_natsorted(
df["Market Value"],
key=lambda x: imps.unit_finder.sub(imps.unit_replacer, x),
reverse=True,
)
df = df.reindex(key)
df = df.iloc[:num]
df.set_index("Ticker", inplace=True)
title = f"ETF's Holding {ticker.upper()}"
dindex = len(df.index)
if dindex > 15:
embeds: list = []
# Output
i, i2, end = 0, 0, 15
df_pg, embeds_img, images_list = [], [], []
while i < dindex:
df_pg = df.iloc[i:end]
df_pg.append(df_pg)
fig = imps.plot_df(
df_pg,
fig_size=(800, (40 * dindex)),
col_width=[0.6, 3.5, 0.65, 1.1],
tbl_header=imps.PLT_TBL_HEADER,
tbl_cells=imps.PLT_TBL_CELLS,
font=imps.PLT_TBL_FONT,
row_fill_color=imps.PLT_TBL_ROW_COLORS,
paper_bgcolor="rgba(0, 0, 0, 0)",
)
fig.update_traces(cells=(dict(
align=["center", "center", "center", "right"])))
imagefile = "etf-byticker.png"
imagefile = imps.save_image(imagefile, fig)
if imps.IMAGES_URL or not imps.IMG_HOST_ACTIVE:
image_link = imps.multi_image(imagefile)
images_list.append(imagefile)
else:
image_link = imps.multi_image(imagefile)
embeds_img.append(f"{image_link}", )
embeds.append(disnake.Embed(
title=title,
colour=imps.COLOR,
), )
i2 += 1
i += 15
end += 15
# Author/Footer
for i in range(0, i2):
embeds[i].set_author(
name=imps.AUTHOR_NAME,
url=imps.AUTHOR_URL,
icon_url=imps.AUTHOR_ICON_URL,
)
embeds[i].set_footer(
text=imps.AUTHOR_NAME,
icon_url=imps.AUTHOR_ICON_URL,
)
i = 0
for i in range(0, i2):
embeds[i].set_image(url=embeds_img[i])
i += 1
embeds[0].set_footer(text=f"Page 1 of {len(embeds)}")
choices = [
disnake.SelectOption(label="Home", value="0", emoji="🟢"),
]
output = {
"view": imps.Menu,
"title": title,
"embed": embeds,
"choices": choices,
"embeds_img": embeds_img,
"images_list": images_list,
}
else:
fig = imps.plot_df(
df,
fig_size=(800, (40 * dindex)),
col_width=[0.6, 3.5, 0.65, 1.1],
tbl_header=imps.PLT_TBL_HEADER,
tbl_cells=imps.PLT_TBL_CELLS,
font=imps.PLT_TBL_FONT,
row_fill_color=imps.PLT_TBL_ROW_COLORS,
paper_bgcolor="rgba(0, 0, 0, 0)",
)
fig.update_traces(cells=(dict(
align=["center", "center", "center", "right"])))
imagefile = imps.save_image("etf-holdings.png", fig)
output = {
"title": title,
"imagefile": imagefile,
}
return output
window_size = driver.execute_script(
"""
return [window.outerWidth - window.innerWidth + arguments[0],
window.outerHeight - window.innerHeight + arguments[1]];
""", width, height)
driver.set_window_size(*window_size)
# options = webdriver.ChromeOptions()
# options.add_argument("--start-maximized")
# options.add_argument(f'user-agent={userAgent}')
# driver = webdriver.Chrome(executable_path=PATH, chrome_options=options)
options = uc.ChromeOptions()
#options.add_argument("--start-maximized")
#options.add_argument(f'user-agent={userAgent}')
driver = uc.Chrome(options=options)
set_viewport_size(driver)
driver.delete_all_cookies()
def loginCMC():
try:
emailInput = WebDriverWait(driver, 5).until(
EC.presence_of_element_located(
(By.XPATH,
'/html/body/div[2]/div/div[2]/div[3]/input[@type="email"]')))
emailInput.clear()
emailInput.send_keys(username)
time.sleep(2)
passwordInput = WebDriverWait(driver, 5).until(
EC.presence_of_element_located((
import undetected_chromedriver.v2 as uc
from flask import Flask, jsonify
from bs4 import BeautifulSoup
import os
app = Flask('')
chrome_options = uc.ChromeOptions()
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')
driver = uc.Chrome(options=chrome_options)
@app.route('/v3/bedwars/')
def bedwarsv3():
global driver
url = "https://www.spigotmc.org/resources/screaming-bedwars-1-9-1-16.63714/"
driver.get_in(url)
soup = BeautifulSoup(driver.page_source, "html.parser")
data = soup.find("dl", {
"class": "downloadCount"
}).find("dd").text.replace(",", "")
return jsonify({"result": data})
app.run(host="0.0.0.0", port=8080)
# coding: utf-8
import logging
import os
import sys
import undetected_chromedriver.v2 as uc
# it's not required to enable logging for cdp events to work
# but as this is a test, it's good too it all
logging.basicConfig(level=10)
logging.getLogger("urllib3").setLevel(logging.WARNING)
logging.getLogger("selenium.webdriver.remote.remote_connection").setLevel(
logging.WARN)
driver = uc.Chrome(enable_cdp_events=True)
# set the callback to Network.dataReceived to print (yeah not much original)
driver.add_cdp_listener("Network.dataReceived", print)
# example of executing regular cdp commands
driver.execute_cdp_cmd("Network.getAllCookies", {})
# okay another one
driver.execute_cdp_cmd(
"Page.addScriptToEvaluateOnNewDocument",
{"source": """ alert('another new document')"""},
)
# set the callback for ALL events (this may slow down execution)
# driver.add_cdp_listener('*', print)
