def playlist_item_data_extractor(playlist_item: WebElement):
# <!-- Pass one element into this -->
playlist_item_data_list: list[
WebElement] = playlist_item.find_elements_by_css_selector(
YT_FORMATTED_STRING_CSS)
# <!-- Song ID -->
song_link = playlist_item_data_list[0].find_element_by_tag_name(
'a').get_attribute('href')
song_id = song_url_to_song_id(song_link)
# <!-- Song Name -->
song_name = playlist_item_data_list[0].get_attribute('title')
# <!-- Song Artists -->
song_artist = playlist_item_data_list[1].get_attribute('title')
# <!-- Song Album (if) -->
song_album = playlist_item_data_list[2].get_attribute('title')
# <!-- Song Duration -->
song_time_stfr = playlist_item_data_list[3].get_attribute('title')
song_duration = stfr_time_to_integer_time(song_time_stfr)
# <!-- -->
return {
'song_id': song_id,
'song_name': song_name,
'song_artist': song_artist,
'song_album': song_album,
'song_duration': song_duration
}
def analyze_element(self, el: WebElement):
# product
product_name = el.find_element_by_xpath(
'.//div/span[@class="plan-name"]').text
# price
price_element = el.find_element_by_xpath(
'.//div/div[@class="plan-wrapper"]/span')
price = re.search(r'(\d+(\.\d+)?)', price_element.text).group()
# term
term = re.search(r'(\d+(\.\d+)?)', product_name).group()
# download
link = el.find_elements_by_css_selector("a.plan-link")
self.client.execute_script("arguments[0].click();", link[1])
self.wait_for()
dialog_element = self.wait_until("pdf-modal-dialog", by=By.CLASS_NAME)
pdf_iframe_element = dialog_element.find_element_by_id("pdfframe")
self.client.switch_to.frame(pdf_iframe_element)
download_button = self.wait_until("download")
download_button.click()
self.client.switch_to.default_content()
close_button_element = dialog_element.find_element_by_xpath(
'.//button')
close_button_element.click()
return {
'term': term,
'price': price,
'product_name': product_name,
}
def _table_columns_texts(row: WebElement) -> List[str]:
""" Return table columns' texts
:param row: table row element
:return: columns' texts
"""
columns = row.find_elements_by_css_selector('td')
return [column.text for column in columns]
def check_visible_quick(self,
selector: str,
within: WebElement = None) -> bool:
"""Check for an element without potentially spending a lot of time polling the DOM.
Ususally used when asserting an element's absence, saves waiting the full timeout."""
within = within or self.driver
self.driver.implicitly_wait(SHORT_WAIT)
elements = within.find_elements_by_css_selector(selector)
self.driver.implicitly_wait(LONG_WAIT)
return len(elements) != 0 and elements[0].is_displayed()
def flashy_find_elements(self,
selector: str,
within: WebElement = None) -> ELEMENT_LIST:
"""Finds multiple elements that match a CSS selector, highlights them as well.
The browser-provided webdriver self.driver implementations seem to not return a
list when only one element matches, so fixing that here."""
within = within or self.driver
return self.blip_element(
to_list(within.find_elements_by_css_selector(selector)))
def find_visible_element(self,
selector: str,
within: WebElement = None) -> WebElement:
"""Given a selector that could match multiple different elements,
return the one that is currently visible, not the first one that matches."""
within = within or self.driver
return self.blip_element([
x for x in within.find_elements_by_css_selector(selector)
if x.is_displayed()
][0])
def _table_rows(table_element: WebElement,
header=True) -> List[WebElement]:
""" Return table rows
:param table_element: table element
:param header: skips the header when true if table has a header
:return: table rows elements
"""
first_row = 1 if header else 0
return table_element.find_elements_by_css_selector('tr')[first_row:]
def get_hires(driver: webdriver.Chrome,
table: WebElement) -> Iterator[WebElement]:
idx = 0
while True:
hires = table.find_elements_by_css_selector(
f"tr.post:nth-child(n+{idx * 2 + 2})")
for hire in hires:
yield hire
if len(hires) == 0:
break
idx += len(hires)
driver.execute_script("getPosts();")
def __assert_csv_table(self, table: WebElement, expects: dict) -> None:
self.assertTrue(table)
expect_header = expects['header'] if 'header' in expects.keys() else []
expect_body = expects['body'] if 'body' in expects.keys() else []
self.assertTrue(table.find_elements_by_css_selector('thead > tr > th'))
headers = table.find_elements_by_css_selector('thead > tr > th')
self.assertTrue(table.find_element_by_tag_name('tbody'))
body = table.find_element_by_tag_name('tbody')
if expect_header:
for (i, header) in enumerate(headers):
self.assertEqual(expect_header[i], header.text)
else:
self.__logger.info(f'{__name__}: header is no check.')
if expect_body:
for (i, row) in enumerate(body.find_elements_by_tag_name('tr')):
expect_tr = expect_body[i]
for (j, td) in enumerate(row.find_elements_by_tag_name('td')):
self.assertEqual(expect_tr[j], td.text)
else:
self.__logger.info(f'{__name__}: body is no check.')
def get_elements_static(target_element: WebElement, verifier: SelecElement) ->[]:
try:
elements = None
if verifier.element_type == NavEleType.IsId:
elements = target_element.find_elements_by_id(verifier.target)
elif verifier.element_type == NavEleType.IsClass:
elements = target_element.find_elements_by_class_name(verifier.target)
elif verifier.element_type == NavEleType.IsCssSelector:
elements = target_element.find_elements_by_css_selector(verifier.target)
elif verifier.element_type == NavEleType.IsName:
elements = target_element.find_elements_by_name(verifier.target)
else:
raise ValueError("Selector not Supported")
return elements
except Exception as inst:
print(type(inst))
print(inst.args)
return None
def get_menu_item(ele: WebElement) -> MenuItem:
"""
:param ele:
:return:
"""
url = ele.find_element_by_tag_name('a')
menu_title = url.text
menu_url = url.get_attribute('href')
menu_item = MenuItem(menu_title, menu_url)
nodes = ele.find_elements_by_css_selector("ul > li")
for node in nodes:
sub_menu = get_menu_item(node)
menu_item.nodes.append(sub_menu)
return menu_item
async def analyzepost(post: WebElement):
files.seen_posts += 1
await files.savestats()
commentslink = None
for element in post.find_elements_by_css_selector("footer div a"):
if "commentaire" in element.text:
commentslink = element.get_attribute("href")
if not commentslink:
return
await switchtab(1)
driver.get(commentslink)
files.analyzed_posts += 1
await files.savestats()
await analyzecomments()
await switchtab(0)
def get_elements_static(target_element: WebElement,
verifier: SelecElement) -> []:
try:
elements = None
if verifier.element_type == NavEleType.IsId:
elements = target_element.find_elements_by_id(verifier.target)
elif verifier.element_type == NavEleType.IsClass:
elements = target_element.find_elements_by_class_name(
verifier.target)
elif verifier.element_type == NavEleType.IsCssSelector:
elements = target_element.find_elements_by_css_selector(
verifier.target)
elif verifier.element_type == NavEleType.IsName:
elements = target_element.find_elements_by_name(
verifier.target)
else:
raise ValueError("Selector not Supported")
return elements
except Exception as inst:
print(type(inst))
print(inst.args)
return None
def get_table_headers(reference_table: WebElement) -> List[str]:
headers = reference_table.find_elements_by_css_selector("thead > tr > th")
table_headers = [h.text for h in headers]
return table_headers
def get_form_inputs(self, form: WebElement) -> t.Iterable[WebElement]:
inputs_selector = ('input:not(.hidden):not([type="hidden"])'
':not([type="submit"])')
return filter(self.get_input_name,
form.find_elements_by_css_selector(inputs_selector))
def quietly_find_elements(self,
selector: str,
within: WebElement = None) -> ELEMENT_LIST:
"""Finds multiple elements that match a CSS selector, optionally within a given element."""
within = within or self.driver
return to_list(within.find_elements_by_css_selector(selector))
def get_table_data(reference_table: WebElement) -> List[WebElement]:
table_data = reference_table.find_elements_by_css_selector("tbody > tr")
return table_data
def get_table_row_columns(row: WebElement) -> List[WebElement]:
columns = row.find_elements_by_css_selector("td")
return columns
def encontra_filhos(element: WebElement, selector: str) -> list[WebElement]:
return element.find_elements_by_css_selector(selector)
def _is_train_wrapper(wrapper: WebElement):
train_wraps = wrapper.find_elements_by_css_selector("[data-original-title=\"Vlak\"]")
return len(train_wraps) > 0
def get_classes(gym_timetable: webelement.WebElement):
"""Get all classes for a week"""
classes = gym_timetable.find_elements_by_css_selector(
'div[class="fkl-cal-td fkl-class"]')
logging.info(f'got {len(classes)} classes')
return classes
def get_form_textareas(self, form: WebElement) -> t.Iterable[WebElement]:
selector = 'textarea:not(.hidden):not([type="hidden"])'
return filter(self.get_input_name,
form.find_elements_by_css_selector(selector))
