class Whats:
def __init__(self):
self._url = 'https://web.whatsapp.com/'
self.driver = Chrome()
self.driver.implicitly_wait(30)
self.bot = Bot()
self.lista = (By.ID, 'pane-side')
self.grupo_name = input('Insira o nome de um contato ou grupo: ')
self.grupo = (By.XPATH, f"//span[@title='{self.grupo_name}']")
self.Ler_mensagens = (By.XPATH, '//div[contains(@class,"message-in focusable-list-item")]')
self.box_msg = (By.CLASS_NAME,'_3uMse')
self.btn = (By.XPATH, f'//span[@data-icon="send"]')
self.driver.get(self._url)
sleep(10)
def groupo(self):
for grupos in self.driver.find_elements(*self.lista):
grupos.find_element(*self.grupo).click()
sleep(2)
def ler_msg(self):
conv = list()
for total in self.driver.find_elements(*self.Ler_mensagens):
conv.append(total.text.split('\n')[-1])
conv[-1].pop()
# conv = '\n'.join(conv[-1][1:])
# if conv.startswith('Encaminhada'):
# return conv.replace('Encaminhada','')
# else:
return conv[-1]
def envia_msg(self, msg = None):
if msg != None or msg != '':
Box = self.driver.find_element(*self.box_msg)
Box.click()
Box.send_keys(msg+'\n')
print(msg)
else:
pass
def conversas(self):
self.bot.aprender()
conversas = set()
self.groupo()
self.envia_msg('Assistente iniciado!!')
conversas.add('Assistente iniciado!!')
print('Procurando Mensagens!!')
while True:
al = self.ler_msg()
if al not in conversas:
print(al)
bot = self.bot.retorno_chat(al)
conversas.add(al)
conversas.add(str(bot))
self.envia_msg(str(bot))
def add_more_information(self, driver: webdriver.Chrome):
string_additional_info = ''
if (self.question.input_type == HTMLConstants.InputTypes.CHECK_BOX) or \
(self.question.input_type == HTMLConstants.InputTypes.RADIO):
list_spans: List[FirefoxWebElement] = driver.find_elements(
By.XPATH,
IndeedConstants.XPath.compute_xpath_radio_span(self.name))
list_spans = [
span for span in list_spans
if span.get_attribute(HTMLConstants.Attributes.CLASS) !=
IndeedConstants.Class.HELP_BLOCK
]
assert len(list_spans) == len(self.element_list)
for i, span in enumerate(list_spans):
string_additional_info += '{0}{1}'.format(
span.get_attribute(HTMLConstants.Attributes.INNER_TEXT),
ModelConstants.DELIMITER.ANSWER)
elif self.question.tag_type == HTMLConstants.TagType.SELECT:
select = Select(driver.find_element(By.NAME, self.name))
list_options: List[FirefoxWebElement] = select.options
for option in list_options:
string_additional_info += '{0}{1}'.format(
option.get_attribute(HTMLConstants.Attributes.INNER_TEXT),
ModelConstants.DELIMITER.ANSWER)
self.question.additional_info = string_additional_info
def test_post_count_on_cypress_label():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Inicjalizacja elementu z labelką
label = browser.find_element(By.LINK_TEXT, 'Cypress')
# Kliknięcie na labelkę
label.click()
#Czekanie na stronę
wait = WebDriverWait(browser, 10)
grey_status_bar = (By.CLASS_NAME, 'status-msg-body')
wait.until(
expected_conditions.visibility_of_element_located(grey_status_bar))
# Pobranie listy tytułów
titles = browser.find_elements(By.CSS_SELECTOR, 'input.gsc-input')
# Asercja że lista ma 1 element
assert len(titles) == 1
# Zamknięcie przeglądarki
browser.close()
def test_post_count_on_cypress_label():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Inicjalizacja elementu z labelką
category = browser.find_element_by_link_text('Cypress')
# Kliknięcie na labelkę
category.click()
# Czekanie na stronę
time.sleep(5)
# Pobranie listy tytułów
list_of_entries = browser.find_elements(By.CSS_SELECTOR, '.post-title a')
# Asercja że lista ma 1 element
assert len(list_of_entries) == 1
# Zamknięcie przeglądarki
browser.quit()
def test_post_count_after_search():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Inicjalizacja searchbara i przycisku search
search_bar = browser.find_element(By.CSS_SELECTOR, 'input.gsc-input')
search_button = browser.find_element(By.CSS_SELECTOR,
'input.gsc-search-button')
# Szukanie
search_bar.send_keys('cypress')
search_button.click()
# Czekanie na stronę
wait = WebDriverWait(browser, 10)
grey_status_bar = (By.CLASS_NAME, 'status-msg-body')
wait.until(
expected_conditions.visibility_of_element_located(grey_status_bar))
# Pobranie listy tytułów
titles = browser.find_elements(By.CLASS_NAME, 'post-title')
# Asercja że lista ma 3 elementy
assert len(titles) == 3
# Zamknięcie przeglądarki
browser.close()
def get_sms(phone, from_='', timestamp=0):
logger.info("Getting sms from=%s", from_)
options = ChromeOptions()
options.add_argument('headless')
driver = None
try:
driver = Chrome(chrome_options=options)
driver.get('https://smska.us/')
locator = (By.XPATH,
"//div[@class='phone_body %s']/div[@class='bodysms']" %
phone.replace('+7', ''))
res = []
for el in driver.find_elements(*locator):
number = el.find_element_by_xpath(
"./div[@class='smsnumber']").text.strip()
date = el.find_element_by_xpath(
"./div[@class='smsdate']").text.strip()
ts = datetime.strptime(date, '%Y-%m-%d %H:%M:%S').timestamp()
message = el.find_element_by_xpath(
"./div[@class='textsms']").text.strip()
res.append((number, ts, message))
if from_:
res = list(filter(lambda o: o[0] == from_, res))
if timestamp:
res = list(filter(lambda o: o[1] > timestamp, res))
return res
finally:
driver.quit()
def test_post_count_after_search():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Inicjalizacja searchbara i przycisku search
search_input = browser.find_element_by_css_selector("input.gsc-input")
search_button = browser.find_element_by_css_selector('.gsc-search-button')
# Szukanie
search_input.send_keys('cypress')
search_button.click()
# Czekanie na stronę
time.sleep(5) # czekamy na posty
# Pobranie listy tytułów
list_of_post = browser.find_elements(By.CSS_SELECTOR, '.post-title a')
# Asercja że lista ma 3 elementy
assert len(list_of_post) == 3
# Zamknięcie przeglądarki
browser.quit()
def test_searching_in_duckduckgo():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony duckduckgo
browser.get('https://duckduckgo.com/')
# Znalezienie paska wyszukiwania
search_form = browser.find_element(By.CSS_SELECTOR,
'#search_form_input_homepage')
# Znalezienie guzika wyszukiwania (lupki)
search_button = browser.find_element_by_id('search_button_homepage')
# Asercje że elementy są widoczne dla użytkownika
assert search_form.is_displayed()
assert search_button.is_displayed() is True
# Szukanie Vistula University
search_form.send_keys('Vistula University')
search_button.click()
# Sprawdzenie że akikolwiek wynik ma tytuł 'Vistula University in Warsaw'
list = browser.find_elements(By.CSS_SELECTOR, '.result__title')
list_of_titles = []
for i in list:
list_of_titles.append(i.text)
assert 'Vistula University in Warsaw' in list_of_titles
assert list == 'Vistula University in Warsaw'
# Zamknięcie przeglądarki
browser.quit()
def is_in_add_page(driver: webdriver.Chrome) -> bool:
"""判断是否进入了添加成员页面"""
if len(driver.find_elements(By.CSS_SELECTOR, '#username')) > 0:
return True
driver.find_element(
By.CSS_SELECTOR,
'[class|=ww_operationBar] .qui_btn.ww_btn.js_add_member').click()
return False
def get_resource_urls(browser: Chrome) -> List[str]:
entries = browser.find_elements(By.CLASS_NAME, 'result-item')
links = [
entry.find_element(By.TAG_NAME, 'a').get_attribute('href')
for entry in entries
if entry.find_element(By.CLASS_NAME, 'result-type').text != 'Web Pages'
]
return links
def test_post_count():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Pobranie listy tytułów
list_of_titles = browser.find_elements(By.CSS_SELECTOR,'.post-title.entry-title')
class Game():
def __init__(self, game_url=None):
self.name = 'tetris'
options = Options()
# ヘッドレスモードを有効にする（次の行をコメントアウトすると画面が表示される）。
options.add_argument('--headless')
options.add_argument('--no-sandbox')
# ChromeのWebDriverオブジェクトを作成する。
self.driver = Chrome(chrome_options=options)
# Googleのトップ画面を開く。
self.driver.get(GAME_URL if game_url is None else game_url)
self.enable_actions = [Keys.LEFT, Keys.RIGHT, Keys.UP, Keys.DOWN]
self.time = time()
self.before_state = None
def reset(self):
self.game_start()
return None, None
def step(self, action):
self.driver.find_element_by_tag_name('body').send_keys(action)
block_text = self.driver.find_element_by_class_name('block-text')
states = [
int(i) for i in block_text.get_attribute('data-value').split(',')
]
reward = int(self.driver.find_element_by_id('point').text)
s = np.array(states).reshape(20, 10)
under_state = s[-1]
if self.before_state is None:
self.before_state = copy(under_state)
a = self.before_state
else:
a = np.clip(under_state - self.before_state, 0, 1)
self.before_state = copy(under_state)
reward += np.sum(a) * 0.5
game_over = self.game_over()
if game_over:
reward -= 3
self.before_state = None
return states, reward, game_over, {}
def game_start(self):
start_button = self.driver.find_element_by_id('button')
start_button.click()
def game_over(self):
ids = self.driver.find_elements(By.ID, 'game-over')
if len(ids) > 0:
return True
return False
def download_images(driver: webdriver.Chrome, chapter):
path = img_path(chapter)
Path(path).mkdir(parents=True, exist_ok=True)
elements = driver.find_elements(By.TAG_NAME, "img")
for element in elements:
src = element.get_attribute('src')
name = img_name(src)
png_path = f'{path}/{name}.png'
if os.path.exists(png_path):
continue
element.screenshot(png_path)
def GetSkills(driver: webdriver.Chrome) -> list:
"""Returns all the skills
Args:
driver (webdriver): driver
Returns:
list<string>: all the skills
"""
result: list = list()
for skill in driver.find_elements(By.CSS_SELECTOR, selectors.SKILLS):
result.append(skill.text.strip(' \t\n\r'))
return result
def get_start(url):
try:
driver = Chrome('./chromedriver.exe')
driver.get(url)
#找'掛號'類標籤
c = driver.find_elements(By.XPATH,
'//img[@class="z_h_9d80b z_h_2f2f0"]')
for i in c:
i.click()
# c = driver.find_elements_by_class_name('z_h_9d80b z_h_2f2f0')
except SeleinumExc:
return 0
def test_searching_in_duckduckgo():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony duckduckgo
browser.get('https://duckduckgo.com/')
# Znalezienie paska wyszukiwania
search_form_ = browser.find_element(By.CSS_SELECTOR,
'#search_form_input_homepage')
# Znalezienie guzika wyszukiwania (lupki)
search_button = browser.find_element_by_id('search_button_homepage')
# metoda submit to to samo co click w 90%
# send.Keys ('tekst'), na elemencie możemy też zrobić asercje
# Asercje że elementy są widoczne dla użytkownika
assert search_button.is_displayed(
) #nasze zmienne tu wrzucamy i możemy też dla czytelnika, napisać is True
assert search_form_.is_displayed()
# Szukanie Vistula University
search_form_.send_keys("Vistula Uniwersity") #wyślij klucze
search_button.click() #kliknij
# Sprawdzenie że jakikolwiek wynik ma tytuł 'Vistula University in Warsaw',nie że pierwszy, ale, że jakikolwiek wynik ma taki tytuł
#lista el. z tytułem, czyli selector typu result_title
list = browser.find_elements(
By.CSS_SELECTOR, '.result_title') #tworzymy listę elementów z tytułami
# browser.find_element zwraca nam unikatowy el, a jak on nie jest unikatowy zwraca pierwszy wynik
# browser.find_elements zwraca nam wszystkie element
list_of_titles = [
] # tworzymy pustą listę i do każdego el. dodajemy i text, listę el selenium, przrobilismy na stringi i sprawdzamy cz nasz text tu jest
for i in list:
list_of_titles.append(i.text)
assert 'Vistula University in Warsaw' in list_of_titles
# Zamknięcie przeglądarki
browser.quit()
class BotWeb():
def __init__(self):
op = Options()
op.headless = True
self.driver = Chrome(options=op)
self.driver.implicitly_wait(15)
self.respostas = (By.CLASS_NAME,'WAC__bot-message')
self.pergunta = (By.CLASS_NAME,'WAC__TextArea-textarea')
self.btn = (By.ID,'WAC__send-button')
self.WaitText = (By.CLASS_NAME, 'WAC__RichText')
self.retorno = 'Did you mean:'
self.retorno2 = 'Ainda não fui treinado para falar sobre esse assunto...'
# self._url = 'https://web-chat.global.assistant.watson.cloud.ibm.com/preview.html?region=us-south&integrationID=d124b8aa-0744-44e5-9719-3c8675cc9403&serviceInstanceID=ae4691d0-deef-4df0-8b2f-666db7d5d7d6'
self._url = 'https://bityli.com/KzdTC'
def arquivoOK(self,text, resp):
_conv = open('conversas_Ok.txt', 'a', encoding='utf-8')
_conv.writelines(f"pergunta: {text},\n resposta: {resp}\n\n")
_conv.close()
def arquivo_Erro(self,text, resp):
_conv = open('conversas_com_Erro.txt', 'a', encoding='utf-8')
_conv.writelines(f"pergunta: {text},\n resposta: {resp}\n\n")
_conv.close()
def bot(self):
self.driver.get(self._url)
for per in conv:
self.driver.find_element(*self.pergunta).send_keys(per)
sleep(1)
self.driver.find_element(*self.btn).click()
sleep(3)
teste = list(self.driver.find_elements(*self.WaitText))
frase = teste[-2].text
if frase != self.retorno and frase != self.retorno2:
self.arquivoOK(per, frase)
print(per)
print(frase)
print('===' * 50)
else:
self.arquivo_Erro(per, frase)
print(per)
print(frase)
print('===' * 50)
self.driver.close()
self.driver.quit()
def answer_all_questions(self, driver: webdriver.Chrome, job: Job,
dict_qle: Dict[str, QuestionLabelElements]):
# Initialize
names = list(dict_qle.keys())
i = 0
name = names[i]
list_continues: List[FirefoxWebElement] = driver.find_elements(
By.XPATH, IndeedConstants.XPath.BUTTON_CONT)
while True:
qle = dict_qle[name]
state = self._answer_question(driver, job, qle)
if state == self.AnswerState.CANNOT_ANSWER:
job.error = RobotConstants.String.UNABLE_TO_ANSWER
return False
if state == self.AnswerState.NOT_VISIBLE:
for element_continue in list_continues:
try:
element_continue.click()
break
except common.exceptions.ElementNotVisibleException as e:
pass
except common.exceptions.NoSuchElementException as e:
job.error = str(e)
return False
else:
if i == len(names) - 1:
try:
driver.find_element(
By.XPATH,
IndeedConstants.XPath.BUTTON_APPLY).click()
return True
except common.exceptions.NoSuchElementException as e:
job.error = str(e)
return False
except common.exceptions.ElementNotVisibleException as e:
# TODO: Figure out why this happens
driver.find_element(
By.XPATH,
IndeedConstants.XPath.BUTTON_CONT).click()
i -= 1
i += 1
name = names[i]
def GetAllExperiences(driver: webdriver.Chrome) -> list:
"""Returns a list of EExperience, containing all the experiences in a linkedin profile
Args:
driver (webdriver): The page's driver
Returns:
list[EExperience]: A list of EExperience
"""
experiences: list = list()
try:
blocks: WebElement = driver.find_elements(By.CLASS_NAME,
selectors.EXP_BLOCK)
except:
pass
for b in blocks:
experiences.append(GetEExperienceFromBlock(b))
return experiences
def test_post_count():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Pobranie listy tytułów bo było <h1 class = 'a b' i selector .a b
list_of_post = browser.find_elements(By.CSS_SELECTOR,
'.post-title a') # a, bo mam to głębiej, ale nie musi być tego a i tak nam zczyta
# Asercja że lista ma 4 elementy
assert len(list_of_post) == 4
# Zamknięcie przeglądarki
browser.quit()
def test_post_count_on_cypress_label():
# Uruchomienie przeglądarki Chrome. Ścieżka do chromedrivera
# ustawiana automatycznie przez bibliotekę webdriver-manager
browser = Chrome(executable_path=ChromeDriverManager().install())
# Otwarcie strony
browser.get('https://www.awesome-testing.com/')
# Inicjalizacja elementu z labelką
label = browser.find_element(By.LINK_TEXT, 'Cypress')
# Kliknięcie na labelkę
label.click()
# Czekanie na stronę
time.sleep(5)
# Pobranie listy tytułów
titles = browser.find_elements(By.CSS_SELECTOR, 'input.gsc-input')
# Asercja że lista ma 1 element
assert len(titles) == 1
# Zamknięcie przeglądarki
.close()
class BasePage:
def __init__(self, driver=None, username=None, url="", service=Service(ChromeDriverManager().install())):
self._username = username
if not driver:
self._driver = Chrome(service=service)
self._driver.maximize_window()
self._driver.get(f"https://github.com/{url}")
else:
self._driver = driver
def _scroll_to_bottom(self):
self._driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
def _navigate(self, link_text: str):
self._find_visible_enabled(Tag.Link, (Param.Link, Condition.Contains, link_text)).click()
def _fill_form(self, *fields_values: tuple[str, str]):
for field, value in fields_values:
self._find_visible_enabled(Tag.Input, (Param.Name, Condition.Equals, field)).send_keys(value)
def _await_element_to_appear(self, tag: Tag, *pairs: tuple[Param, Condition, str]) -> WebElement:
WebDriverWait(self._driver, 5).until(visibility_of_element_located((By.XPATH, create(tag, *pairs))))
return self._find_visible_enabled(tag, *pairs)
def _await_element_to_enable(self, tag: Tag, *pairs: tuple[Param, Condition, str]) -> WebElement:
WebDriverWait(self._driver, 5).until(any_of(*[element_to_be_clickable(elem) for elem in self._driver.find_elements(By.XPATH, create(tag, *pairs))]))
return self._find_visible_enabled(tag, *pairs)
def _find_visible_enabled(self, tag: Tag, *pairs: tuple[Param, Condition, str]) -> Optional[WebElement]:
for elem in self._driver.find_elements(By.XPATH, create(tag, *pairs)):
if elem.is_enabled() and elem.is_displayed():
return elem
@staticmethod
def _find_children_visible_enabled(elem: WebElement, tag: Tag) -> list[Optional[WebElement]]:
return [e for e in elem.find_elements(By.XPATH, f".//{tag.value}") if e.is_enabled() and e.is_displayed()]
def report_day(browser: webdriver.Chrome,
ShouJHM, ShiFSH, ShiFZX, ddlSheng, ddlShi, ddlXian, XiangXDZ, ShiFZJ,
t: dt.datetime):
print(f'正在填报{t.year}-{t.month}-{t.day}')
browser.get(f'https://selfreport.shu.edu.cn/DayReport.aspx?day={t.year}-{t.month}-{t.day}')
time.sleep(1)
print('承诺')
browser.find_element(By.ID, 'p1_ChengNuo-inputEl-icon').click()
checkboxes = browser.find_elements(By.CSS_SELECTOR, '#p1_pnlDangSZS .f-field-checkbox-icon')
if len(checkboxes) > 0: # 有的人没有答题
print('答题')
checkboxes[0].click()
print('是否在上海', ShiFSH)
# 在上海（校内），在上海（不在校内），不在上海
checkboxes = browser.find_elements(By.CSS_SELECTOR, '#p1_ShiFSH .f-field-checkbox-icon')
if ShiFSH == '在上海（不在校内）':
checkboxes[1].click()
elif ShiFSH == '不在上海':
checkboxes[2].click()
else:
checkboxes[0].click()
time.sleep(1)
print('是否住校', ShiFZX)
try:
checkboxes = browser.find_elements(By.CSS_SELECTOR, '#p1_ShiFZX .f-field-checkbox-icon')
checkboxes[0 if ShiFZX else 1].click()
except Exception as e:
print('是否住校提交失败')
print('省市县详细地址', ddlSheng, ddlShi, ddlXian, XiangXDZ[:2])
elem = browser.find_element(By.CSS_SELECTOR, "#p1_ddlSheng input[name='p1$ddlSheng$Value']")
browser.execute_script('''
var elem = arguments[0];
var value = arguments[1];
elem.value = value;
''', elem, ddlSheng)
elem = browser.find_element(By.CSS_SELECTOR, "#p1_ddlShi input[name='p1$ddlShi$Value']")
browser.execute_script('''
var elem = arguments[0];
var value = arguments[1];
elem.value = value;
''', elem, ddlShi)
elem = browser.find_element(By.CSS_SELECTOR, "#p1_ddlXian input[name='p1$ddlXian$Value']")
browser.execute_script('''
var elem = arguments[0];
var value = arguments[1];
elem.value = value;
''', elem, ddlXian)
elem = browser.find_element(By.CSS_SELECTOR, "#p1_XiangXDZ #p1_XiangXDZ-inputEl")
browser.execute_script('''
var elem = arguments[0];
var value = arguments[1];
elem.value = value;
''', elem, XiangXDZ)
print('是否家庭地址', ShiFZJ)
checkboxes = browser.find_elements(By.CSS_SELECTOR, '#p1_ShiFZJ .f-field-checkbox-icon')
checkboxes[0 if ShiFZJ else 1].click()
time.sleep(0.5)
# 随申码
try:
SuiSM = browser.find_element(By.ID, 'p1_pImages_HFimgSuiSM-inputEl')
if SuiSM.get_attribute('value') == '':
print('未检测到已提交随申码')
upload = browser.find_element(By.NAME, 'p1$pImages$fileSuiSM')
upload.send_keys(draw_XingCM(ShouJHM, t))
WebDriverWait(browser, 10).until(
element_has_no_value((By.NAME, 'p1$pImages$fileSuiSM'))
)
browser.find_element(By.CSS_SELECTOR, '#p1_pImages_fileSuiSM a.f-btn').click()
WebDriverWait(browser, 10).until(
element_has_value((By.ID, 'p1_pImages_HFimgSuiSM-inputEl'))
)
print(SuiSM.get_attribute('value'))
else:
print(f'已提交随申码')
except Exception as e:
print(e)
print('随申码提交失败')
# 行程码
try:
XingCM = browser.find_element(By.ID, 'p1_pImages_HFimgXingCM-inputEl')
if XingCM.get_attribute('value') == '':
print('未检测到已提交行程码')
upload = browser.find_element(By.NAME, 'p1$pImages$fileXingCM')
upload.send_keys(draw_XingCM(ShouJHM, t))
WebDriverWait(browser, 10).until(
element_has_no_value((By.NAME, 'p1$pImages$fileXingCM'))
)
browser.find_element(By.CSS_SELECTOR, '#p1_pImages_fileXingCM a').click()
WebDriverWait(browser, 10).until(
element_has_value((By.ID, 'p1_pImages_HFimgXingCM-inputEl'))
)
print(XingCM.get_attribute('value'))
else:
print(f'已提交行程码')
except Exception as e:
print(e)
print('行程码提交失败')
# 确认提交
browser.find_element(By.ID, 'p1_ctl02_btnSubmit').click()
messagebox = WebDriverWait(browser, 10).until(
EC.presence_of_element_located((By.CLASS_NAME, 'f-messagebox'))
)
if '确定' in messagebox.text:
for a in messagebox.find_elements(By.TAG_NAME, 'a'):
if a.text == '确定':
a.click()
break
time.sleep(2)
messagebox = WebDriverWait(browser, 10).until(
EC.presence_of_element_located((By.CLASS_NAME, 'f-messagebox'))
)
if '提交成功' in messagebox.text:
return True
else:
print(messagebox.text)
return False
else:
print(messagebox.text)
return False
cleantext = re.sub(cleanr, '', raw_html)
return cleantext
ua = UserAgent()
options = Options()
options.headless = True
options.add_argument('--no-sandbox')
options.add_argument('--window-size=1920,1080')
options.add_argument('--allow-insecure-localhost')
options.add_experimental_option('excludeSwitches', ['enable-logging'])
driver = Chrome(options=options)
# driver.quit()
driver.get("https://cyberleninka.ru/article/c/computer-and-information-sciences")
last_page_id = driver.find_elements(By.CSS_SELECTOR, 'ul.paginator li')[
-1].find_elements_by_tag_name("a")[0].get_attribute('href').split('/')[-1]
last_page_id = int(last_page_id)
# print(last_page_id)
cleanup_pattern = re.compile(r'\[.*?\]|[\+\*\/\\!@#$%^&*]+|lt;|gt;|±|-{2,}')
count = 0
with open("cyberleninka2.txt", "a+", encoding='utf-8') as output_file:
output_file.seek(0)
data = output_file.read(100)
if len(data) == 0:
output_file.write("[\n")
for page_id in range(217, last_page_id+1):
print("page start: "+str(page_id))
class kPage():
URL = 'https://www.k-online.de/vis/v1/de/search?oid=102636&lang=1&_query=&'\
'f_type=profile&f_country=IT&_sort=alpha_asc'
CLASS_NAME = 'searchresult-item'
SCROLL_PAUSE_TIME = 1.5
#TAG = 'media__body searchresult-box__media__body one-whole'
def __init__(self, ShowBrowser=True):
"""
Login into the CAMed cloud located at the Medical University Graz, and
created for the COMET projroct CAMed. The cloud alos has a filing system
to store and transport results and other data.
Parameters
----------
ShowBrowser : Boolean, optional
Show browser window. The default is True.
Returns
-------
None.
"""
options = ChromeOptions()
if not ShowBrowser:
options.add_argument('headless')
options.add_argument('window-size=1200x600')
self.__browser = Chrome('/usr/lib/chromium-browser/chromedriver',
options=options)
self.__browser.get(self.URL)
def closeCookies(self):
name = 'Save Settings'
id = '#usercentrics-root'
item = self.__browser.execute_script("return document.querySelector("\
"'{}').shadowRoot".format(id))
for b in item.find_elements(By.TAG_NAME, 'button'):
if b.text.startswith(name):
b.click()
return True
def scrollToButtom(self):
driver = self.__browser
last_height = driver.execute_script(
"return document.body.scrollHeight")
i = 0
while True and i < 5:
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);")
time.sleep(self.SCROLL_PAUSE_TIME)
new_height = driver.execute_script(
"return document.body.scrollHeight")
if new_height == last_height:
break
else:
last_height = new_height
pass
def getEntries(self):
srList = self.__browser.find_elements(By.CLASS_NAME, self.CLASS_NAME)
name = []
location = []
tags = []
for i, sr in enumerate(srList):
name.append(sr.find_element(By.TAG_NAME, 'h3').text)
location.append(sr.find_element(By.TAG_NAME, 'h5').text)
try:
tags.append(
sr.find_element(By.CLASS_NAME,
'flex__item--grow').find_element(
By.TAG_NAME, 'span').text)
except:
tags.append('')
#print(name, location, tags)
return name, location, tags
def makeList(self, name, location, tags, path):
fn = '/ItalyProvince.dat'
prov = {}
with open(path + fn, 'r') as f:
for line in f.readlines():
id, p = line.replace(' ', '').split('\t')[3:5]
prov.update({id: p})
with open(path + '/companies.csv', 'w') as f:
f.write('\Company,location,province,tag')
for n, loc, tag in zip(name, location, tags):
line = n + ','
l = loc.replace(', Italien', '').split('(')
if len(l) != 1:
line += l[0].replace(' ', '') + ','
ID = l[-1].replace(')', '') + ','
for key, item in prov.items():
if ID.startswith(key):
line += item
else:
line += l[0].replace(' ', '') + ',,'
line += tag
f.write('\n' + line)
pass
def close(self):
self.__browser.quit()
啟動Chrome瀏覽器：
from selenium import webdriver
browser = webdriver.Chrome()
browser.get('http://www.baidu.com/')
啟動Firefox瀏覽器：
from selenium import webdriver
browser = webdriver.Firefox()
browser.get('http://www.baidu.com/')
啟動IE瀏覽器：
from selenium import webdriver
browser = webdriver.Ie()
browser.get('http://www.baidu.com/')
'''
local_path = 'imgs'
url = "https://www.shutterstock.com/zh-Hant/category/interiors"
xpath = 'div[@id="content"]'
driver = Chrome(r'./chromedriver')
driver.get(url)
time.sleep(5)
c = driver.find_elements(xpath)
print(c)
driver.close()
def wbes_Px_iex_import():
# set download directory path
p = {'download.default_directory':r'C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\Dumps\wbesPxIexFile'}
#add options to browser
opts.add_experimental_option('prefs', p)
# click on the datepicker select button
previousDate = dt.datetime.today() - dt.timedelta(days=1)
previousDateFormatted = previousDate.strftime('%d-%m-%Y') # format the date to dd-mm-yyyy
month = previousDate.strftime('%B')
prevDate = previousDate.strftime('%d')
prevDate = int(prevDate)
prevDate = str(prevDate)
browser = Chrome(options=opts)
#maximize browser
browser.maximize_window()
wbesRtmIexUrl = 'https://wbes.wrldc.in/Report/PXIndex#date={}|revisionno=null|type=5'.format(previousDateFormatted)
browser.get(wbesRtmIexUrl)
# TEST WAIT UNTIL IN SELENIUM
delay = 60 # seconds
try:
myElem = WebDriverWait(browser, delay).until(EC.presence_of_element_located((By.ID, 'newEffectiveDate')))
except TimeoutException:
print("Loading took too much time!")
# open the calender menu
browser.find_elements_by_xpath("//*[@id=\"newEffectiveDate\"]")[0].click()
# get the month year from website
while(True):
t = browser.find_elements_by_xpath("//*[@id=\"ui-datepicker-div\"]/div/div/span[1]")
monthString = t[0].text
if month == monthString:
break
else:
browser.find_elements_by_xpath("//*[@id=\"ui-datepicker-div\"]/div/a[1]")[0].click()
dateString = browser.find_elements_by_xpath("//*[@id=\"ui-datepicker-div\"]/table/tbody/tr/td/a")
for t in dateString:
if prevDate == t.text:
t.click()
break
delay = 60 # seconds
try:
myElem = WebDriverWait(browser, delay).until(EC.presence_of_element_located((By.ID, 'dwnld')))
except TimeoutException:
print("Loading took too much time!")
# click on different download option dwnld
browser.find_elements_by_id("dwnld")[0].click()
srcFileLocation = r'C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\Dumps\wbesPxIexFile'
destFileLocation = r'C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\Dumps\wbesPxIexFile\Archives'
revNum = getMaxRTMRevForDate(previousDateFormatted,13)
destFileName = "Report-PX_IEX-("+revNum+")-"
moveFilesToArchive(srcFileLocation, destFileLocation, destFileName)
delay = 60 # seconds
try:
myElem = WebDriverWait(browser, delay).until(EC.presence_of_element_located((By.LINK_TEXT, 'Excel')))
except TimeoutException:
print("Loading took too much time!")
browser.find_elements(By.LINK_TEXT,"Excel")[0].click()
print("wbes PX IEX fetch succesful")
time.sleep(10)
browser.close()
os.chdir(srcFileLocation)
for filename in os.listdir(os.getcwd()):
if filename.endswith(".xlsx"):
y=filename
x=filename.replace('('+revNum+')','(0)')
os.rename(os.path.join(srcFileLocation, y), os.path.join(srcFileLocation, x))
class Crispy():
def __init__(self, **kwargs):
# Init
self.logged_in = False
self.start_time = self.current_time()
self.last_wipe = self.start_time
self.last_save = self.start_time
self.cache = []
self.sent = []
self.commands = {}
self.command_help = {}
self.vocabularies = {}
self.vocabulary = None
self.username = kwargs.get('username', None)
self.password = kwargs.get('password', None)
atexit.register(self.shutdown)
# Config
self.config = kwargs
self.bot = kwargs.get('bot', 'Crispybot')
self.room = kwargs.get('room', self.bot)
self.url = kwargs.get('url', 'https://jumpin.chat/'+self.room)
self.login_url = kwargs.get('login_url', 'https://jumpin.chat/login')
self.max_tries = kwargs.get('max_tries', 10)
self.max_len = kwargs.get('max_len', 60)
self.min_len = kwargs.get('min_len', 10)
self.max_cache = kwargs.get('max_cache', 0)
self.refresh_interval = kwargs.get('refresh_interval', 10)
self.sleep_interval = kwargs.get('sleep_interval', 0.1)
self.wipe_interval = kwargs.get('wipe_interval', 10)
self.save_interval = kwargs.get('save_interval', 10)
self.case_sensitive = kwargs.get('case_sensitive', True)
self.similarity_score = kwargs.get('similarity_score', 0.5)
self.triggers = kwargs.get('triggers', [])
self.closed_users = kwargs.get('closed_users', [])
self.banned_users = kwargs.get('banned_users', [])
self.banned_words = kwargs.get('banned_words', [])
self.cleared_words = kwargs.get('cleared_words', [])
self.cleared_users = kwargs.get('cleared_users', [])
self.silenced_words = kwargs.get('silenced_words', [])
self.silenced_users = kwargs.get('silenced_users', [])
self.targets = kwargs.get('targets', [])
self.name_change = kwargs.get('name_change', 'changed their name to')
self.filter = kwargs.get('filter', [])
self.deny_message = kwargs.get('deny_message', '/shrug')
self.ban_command = kwargs.get('ban_command', '/ban')
self.ban_message = kwargs.get('ban_message', '/shrug')
self.unban_command = kwargs.get('unban_command', '/unban')
self.unban_message = kwargs.get('unban_message', '/shrug')
self.close_command = kwargs.get('close_command', '/close')
self.close_message = kwargs.get('close_message', '/shrug')
self.clear_command = kwargs.get('clear_command', '/clear')
self.clear_message = kwargs.get('clear_message', '/shrug')
self.silence_command = kwargs.get('silence_command', '/silence')
self.silence_message = kwargs.get('silence_message', '/shrug')
self.msg_command = kwargs.get('msg_command', '/msg')
self.msg_message = kwargs.get('msg_message', '/shrug')
self.action_command = kwargs.get('action_command', '/me')
self.action_message = kwargs.get('action_message', '/shrug')
self.nick_command = kwargs.get('nick_command', '/nick')
self.nick_message = kwargs.get('nick_message', '/shrug')
self.color_command = kwargs.get('color_command', '/color')
self.color_message = kwargs.get('color_message', '/shrug')
self.clear_banned = kwargs.get('clear_banned', False)
self.trigger_sensitivity = kwargs.get('trigger_sensitivity', 0.0)
self.target_sensitivity = kwargs.get('target_sensitivity', 0.5)
self.admins = kwargs.get('admins', [])
self.prefix = kwargs.get('prefix', '!')
self.debug = kwargs.get('debug', False)
self.browser = None
self.restart_driver()
def __setitem__(self, name, value):
return setattr(self, name, value)
def __getitem__(self, name):
return getattr(self, name)
def restart_driver(self):
if self.browser != None:
self.browser.quit()
options = ChromeOptions()
options.add_argument("window-size=1920,1080")
options.add_argument("disable-gpu")
options.add_argument("disable-extensions")
options.add_argument("start-maximized")
if not self.debug:
options.add_argument('log-level=3')
options.add_argument('headless')
self.browser = Chrome(chrome_options=options)
def update_config(self, conf):
self.config.update(conf)
for key in conf:
setattr(self, key, conf[key])
with open('config.json', '+w', encoding='utf-8') as f:
f.write(json.dumps(self.config, sort_keys=True, indent=2))
def sleep(self, ratio=1):
time.sleep(self.sleep_interval*ratio)
def is_action(self, username, message):
if not message:
return False
return (not username and message[0] == '*')
def filter_message(self, username, message):
filter_set = list(
set(self.filter) | set([self.bot]) | set([self.name_change]) |
set(self.banned_users) | set(self.banned_words) |
set(self.silenced_users) | set(self.silenced_words) |
set(self.cleared_users) | set(self.cleared_words)
)
if not username:
username = ''
profile = self.get_user_profile(username)
for f in filter_set:
if f.lower() in message.lower() or f.lower() == username.lower() or f.lower() == profile.lower():
return False
return True
def is_trained(self,name,username,message):
if not message:
return False
return self.vocabularies[name].has_text(message, username=username)
def is_command(self,message):
if message:
if message[0] == self.prefix:
return self.commands.get(message.split()[0][1:]) != None
return False
def is_trigger(self, message):
if not message:
return False
for t in self.triggers:
for m in message.split():
if SequenceMatcher(None, t.lower(), m.lower()).ratio() > min(max(1-self.trigger_sensitivity,0),1):
return True
return False
def is_banned(self, username, message):
if not message or not username:
return 0
profile = self.get_user_profile(username)
for t in self.banned_users:
if t.lower() == username.lower() or t.lower() == profile.lower():
return 1
for t in self.banned_words:
if t.lower() in message.lower():
return 2
return 0
def is_cleared(self, username, message):
if not message or not username:
return 0
profile = self.get_user_profile(username)
for t in self.cleared_users:
if t.lower() == username.lower() or t.lower() == profile.lower():
return 1
for t in self.cleared_words:
if t.lower() in message.lower():
return 2
return 0
def is_silenced(self, username, message):
if not message or not username:
return 0
profile = self.get_user_profile(username)
for t in self.silenced_users:
if t.lower() == username.lower() or t.lower() == profile.lower():
return 1
for t in self.silenced_words:
if t.lower() in message.lower():
return 2
return 0
def set_command(self, command, func, comment=''):
self.commands[command] = func
self.command_help[command] = comment
def del_command(self, command):
if self.is_command(self.prefix+command):
del self.commands[command]
del self.command_help[command]
def try_command(self, username, message):
for command in self.commands:
if message.split()[0][1:] == command:
self.commands[command](crispy=self,args=message.split()[1:],username=username)
def is_bot(self,username):
if not username:
return False
return username.lower() == self.bot.lower()
def is_target(self,username):
if not username:
return False
if not self.is_bot(username):
profile = self.get_user_profile(username)
for t in self.targets:
if SequenceMatcher(None, t.lower(), username.lower()).ratio() > min(max(1-self.target_sensitivity,0),1):
return True
elif SequenceMatcher(None, t.lower(), profile.lower()).ratio() > min(max(1-self.target_sensitivity, 0), 1):
return True
return False
def add_target(self,target):
if isinstance(target, str):
if target not in self.targets:
self.targets.append(target)
elif isinstance(target,list):
for t in target:
if t not in self.targets:
self.targets.append(t)
self.update_config({'targets': self.targets})
def del_target(self,target):
if isinstance(target, str):
if target in self.targets:
self.targets.remove(target)
elif isinstance(target,list):
for t in target:
if t in self.targets:
self.targets.remove(t)
self.update_config({'targets': self.targets})
def add_admin(self, admin):
if isinstance(admin, str):
if admin not in self.admins:
self.admins.append(admin)
elif isinstance(admin, list):
for t in admin:
if t not in self.admins:
self.admins.append(t)
self.update_config({'admins': self.admins})
def del_admin(self, admin):
if isinstance(admin, str):
if admin in self.admins:
self.admins.remove(admin)
elif isinstance(admin, list):
for t in admin:
if t in self.admins:
self.admins.remove(t)
self.update_config({'admins': self.admins})
def add_trigger(self, trigger):
if isinstance(trigger, str):
if trigger not in self.triggers:
self.triggers.append(trigger)
elif isinstance(trigger, list):
for t in trigger:
if t not in self.triggers:
self.triggers.append(t)
self.update_config({'triggers': self.triggers})
def del_trigger(self, trigger):
if isinstance(trigger, str):
if trigger in self.triggers:
self.triggers.remove(trigger)
elif isinstance(trigger, list):
for t in trigger:
if t in self.triggers:
self.triggers.remove(t)
self.update_config({'triggers': self.triggers})
def add_filter(self, message):
if message not in self.filter:
self.filter.append(message)
self.update_config({'filter': self.filter})
def del_filter(self, message):
if message in self.filter:
self.filter.remove(message)
self.update_config({'filter': self.filter})
def is_admin(self,username):
profile = self.get_user_profile(username)
return profile in self.admins
def has_cache(self):
return len(self.cache) > 0
def is_message_present(self):
try:
self.browser.find_element(By.CSS_SELECTOR, '.chat__Message')
except NoSuchElementException:
return False
else:
return True
def send_message(self, message):
self.sent.append(message)
self.browser.find_element(By.CSS_SELECTOR, '.chat__Input').send_keys(message)
self.browser.find_element(By.CSS_SELECTOR, '.chat__InputSubmit').click()
def send_cached_message(self):
if self.has_cache():
self.send_message(self.cache.pop(0))
def capture_message(self):
chat_message = self.browser.find_elements(By.CSS_SELECTOR, '.chat__Message')[-1]
try:
if ('chat__MessageHandle' in chat_message.get_attribute('innerHTML')):
username = chat_message.find_element(By.CSS_SELECTOR, '.chat__MessageHandle').text
else:
username = None
message = chat_message.find_element(By.CSS_SELECTOR, '.chat__MessageBody').text
except StaleElementReferenceException:
username = ''
message = ''
return username, message
def wait_for_element(self, by, element, t=10):
try:
return WebDriverWait(self.browser, t).until(EC.presence_of_element_located((by, element)))
except TimeoutException:
print('\nTimed out waiting for element "'+element+'". Restarting driver...')
self.logged_in = False
self.restart_driver()
def has_user_account(self):
return self.username and self.password
def login(self):
if self.has_user_account():
self.browser.get(self.login_url)
self.wait_for_element(By.ID, 'username').send_keys(self.username)
self.sleep(5)
self.browser.find_element(By.ID, 'password').send_keys(self.password)
self.sleep(5)
self.browser.find_element(By.XPATH, '//button[text()="Log In"]').click()
print('\nLogging in to account '+self.username)
self.sleep(5)
self.connect()
def connect(self):
print('\nConnecting to '+self.url)
self.last_refresh = self.current_time()
self.browser.get(self.url)
nickname = self.wait_for_element(By.CSS_SELECTOR, '.form__Input-inline')
if nickname:
nickname.clear()
self.sleep(5)
nickname.send_keys(self.bot)
self.sleep(5)
self.browser.find_element(By.XPATH, '//button[text()="Go"]').click()
self.sleep(5)
try:
self.browser.find_element(By.XPATH, '//span[text()="Close cams"]').click()
except (NoSuchElementException, WebDriverException):
print('\nNo open cameras found! Unable to close cams, will try again next refresh.')
if not self.logged_in:
self.sleep(5)
self.browser.find_element(By.CSS_SELECTOR, '.fa-gear').click()
self.sleep(5)
youtube = self.browser.find_element(By.ID, 'enableyoutubevideos')
if youtube.is_selected():
youtube.click()
self.sleep(5)
self.browser.find_element(By.CSS_SELECTOR, '.fa-gear').click()
self.sleep(5)
darkmode = self.browser.find_element(By.ID, 'enabledarktheme')
if not darkmode.is_selected():
darkmode.click()
self.sleep(5)
self.browser.find_element(By.CSS_SELECTOR, '.chat__HeaderOption-streamVolume').click()
self.sleep(5)
self.browser.find_element(By.CSS_SELECTOR, '.chat__HeaderOption-sounds').click()
self.logged_in = True
print('\nLogin complete! Bot is ready to receive messages!')
def reset_userlist(self):
self.browser.execute_script("document.getElementsByClassName('scrollarea-content')[1].style.marginTop = '0px';")
def scroll_userlist(self):
self.browser.execute_script('''
var viewers = Number(document.getElementsByClassName('cams__ViewerCount')[0].textContent)
var userlist = document.getElementsByClassName('scrollarea-content')[1];
var mt = Number(userlist.style.marginTop.replace('px', ''))-30;
if (mt > ((7*30)-(viewers*30))) {
userlist.style.marginTop = mt+'px';
} else {
userlist.style.marginTop = '0px';
}
''')
def click_username(self, username):
if username and not self.is_bot(username):
try:
user = self.browser.find_element(By.XPATH, '//div[contains(@class, "userList__UserHandle") and text()="'+username+'"]')
if user:
while not user.is_displayed():
self.scroll_userlist()
user.click()
self.sleep()
except (WebDriverException, StaleElementReferenceException, NoSuchElementException):
print('\nTried to click {} but username is not displayed!'.format(username))
def click_chat(self):
try:
self.browser.find_element(By.CSS_SELECTOR, '.chat__Input').click()
except (NoSuchElementException, WebDriverException):
print('\nTried to click .chat__Input but element not found. Refreshing page...')
self.refresh()
def get_user_profile(self, username):
profile = ''
if username:
self.click_username(username)
try:
if self.browser.find_element(By.XPATH, '//button[text()="Profile"]'):
profile = self.browser.find_element(By.CSS_SELECTOR, '.dropdown__Option-header').text
except (NoSuchElementException, StaleElementReferenceException):
pass
self.click_chat()
return profile
def ban(self, username, notify=True):
if username:
self.send_message('{} {}'.format(self.ban_command,username))
self.sleep()
if notify:
self.send_message(self.ban_message)
def unban(self, username, notify=True):
if username:
self.send_message('{} {}'.format(self.unban_command,username))
self.sleep()
if notify:
self.send_message(self.unban_message)
def close(self, username, notify=True):
if username:
self.send_message('{} {}'.format(self.close_command,username))
self.sleep()
if notify:
self.send_message(self.close_message)
def silence(self, username, notify=True):
if username:
self.send_message('{} {}'.format(self.silence_command,username))
self.sleep()
if notify:
self.send_message(self.silence_message)
def clear(self, notify=True):
self.send_message(self.clear_command)
self.sleep()
if notify:
self.send_message(self.clear_message)
def msg(self, username,message, notify=True):
if username and message:
self.send_message('{} {} {}'.format(self.msg_command,username,message))
self.sleep()
if notify:
self.send_message(self.msg_message)
def action(self, message, notify=True):
if message:
self.send_message('{} {}'.format(self.action_command,message))
self.sleep()
if notify:
self.send_message(self.action_message)
def nick(self, nickname, notify=True):
if nickname:
self.send_message('{} {}'.format(self.nick_command,nickname))
self.bot = nickname
self.update_config({'bot': self.bot})
self.sleep()
if notify:
self.send_message(self.nick_message)
def color(self, color, notify=True):
if color:
self.send_message('{} {}'.format(self.color_command,color))
self.sleep()
if notify:
self.send_message(self.color_message)
def has_vocabulary(self, name):
return self.vocabularies.get(name, False)
def set_vocabulary(self,name):
if self.has_vocabulary(name):
self.vocabulary = self.vocabularies[name]
self.cache = []
def add_vocabulary(self, name, **kwargs):
file = kwargs.get('file')
type = kwargs.get('type')
if file:
with open(file, 'r', encoding='utf-8') as f:
text = f.read()
if type == 'line':
self.vocabularies[name] = NewlineText(text, **kwargs)
elif type == 'json':
self.vocabularies[name] = JsonText(text, **kwargs)
elif type == 'text':
self.vocabularies[name] = Text(text, **kwargs)
else:
print('Unknown vocabulary type for "{}"'.format(name))
else:
print('Vocabulary file not found for "{}"'.format(name))
def train_vocabulary(self, username, message):
if username and message:
for name in self.vocabularies:
if self.vocabularies[name].training:
if not self.is_trained(name, username, message) and len(message) > self.min_len:
self.vocabularies[name].add_text(message, username=username)
def generate_message(self):
return self.vocabulary.make_short_sentence(self.max_len, tries=self.max_tries)
def generate_message_from(self,username,message):
return self.vocabulary.make_sentence_from(message, self.max_len, self.min_len, tries=self.max_tries, similarity=self.similarity_score, filter=self.sent, username=username, case_sensitive=self.case_sensitive)
def generate_cached_message(self):
if (len(self.cache) < self.max_cache) and self.vocabulary:
text = self.generate_message()
if text:
self.cache.append(text)
def generate_cached_message_from(self,username,message):
if (len(self.cache) < self.max_cache) and self.vocabulary:
text = self.generate_message_from(username,message)
if text:
self.cache.append(text)
def current_time(self):
return int(round(time.time() * 1000))
def save(self, **kwargs):
if (self.current_time()-self.last_save > self.save_interval*60000) or kwargs.get('force'):
self.last_save = self.current_time()
self.cache = []
for name in self.vocabularies:
if self.vocabularies[name].training:
with open(self.vocabularies[name].file, '+w', encoding='utf-8') as f:
f.write(self.vocabularies[name].get_text())
def force_save(self):
self.save(force=True)
def capture_action(self, message):
return message.split()[1], ' '.join(message.split()[1:])
def answer_to(self, username, message):
text = self.generate_message_from(username, message)
if text:
self.send_message(text)
else:
self.send_cached_message()
def wipe_sent_messages(self, **kwargs):
if (self.current_time()-self.last_wipe > self.wipe_interval*60000) or kwargs.get('force'):
self.last_wipe = self.current_time()
self.sent = []
def force_wipe(self):
self.wipe_sent_messages(force=True)
def spam(self, text, amount):
for i in range(amount):
self.send_message(text)
def forget(self, text):
for name in self.vocabularies:
self.vocabularies[name].del_text(text)
def check_for_triggers(self, username, message):
if self.is_target(username) or self.is_trigger(message):
self.answer_to(username, message)
return True
return False
def check_for_banned(self, username, message):
banned = self.is_banned(username, message)
if banned:
self.ban(username)
if banned == 2 and self.clear_banned:
self.clear()
return True
return False
def check_for_cleared(self, username, message):
cleared = self.is_cleared(username, message)
if cleared:
self.clear()
return True
return False
def check_for_silenced(self, username, message):
silenced = self.is_silenced(username, message)
if silenced:
self.silence(username)
return True
return False
def check_for_closed(self):
cam_handles = []
try:
cam_handles = self.browser.find_elements(By.CSS_SELECTOR, '.cams__CamHandle')
except NoSuchElementException:
pass
for handle in cam_handles:
try:
username = handle.text
profile = self.get_user_profile(username)
if username in self.closed_users or profile in self.closed_users:
self.close(username)
except StaleElementReferenceException:
pass
def refresh(self, **kwargs):
if (self.current_time()-self.last_refresh > self.refresh_interval*60000) or kwargs.get('force'):
self.connect()
def force_refresh(self):
self.refresh(force=True)
def add_banned(self, **kwargs):
for b in kwargs.get('users', []):
if b not in self.banned_users:
self.banned_users.append(b)
self.ban(b)
for b in kwargs.get('words', []):
if b not in self.banned_words:
self.banned_words.append(b)
self.ban(b)
self.update_config({'banned_words': self.banned_words, 'banned_users': self.banned_users})
def del_banned(self, **kwargs):
for b in kwargs.get('users', []):
if b in self.banned_users:
self.banned_users.remove(b)
self.unban(b)
for b in kwargs.get('words', []):
if b in self.banned_words:
self.banned_words.remove(b)
self.unban(b)
self.update_config({'banned_words': self.banned_words, 'banned_users': self.banned_users})
def add_cleared(self, **kwargs):
for b in kwargs.get('users', []):
if b not in self.cleared_users:
self.cleared_users.append(b)
for b in kwargs.get('words', []):
if b not in self.cleared_words:
self.cleared_words.append(b)
self.update_config({'cleared_words': self.cleared_words, 'cleared_users': self.cleared_users})
def del_cleared(self, **kwargs):
for b in kwargs.get('users', []):
if b in self.cleared_users:
self.cleared_users.remove(b)
for b in kwargs.get('words', []):
if b in self.cleared_words:
self.cleared_words.remove(b)
self.update_config({'cleared_words': self.cleared_words, 'cleared_users': self.cleared_users})
def add_silenced(self, **kwargs):
for b in kwargs.get('users', []):
if b not in self.silenced_users:
self.silenced_users.append(b)
for b in kwargs.get('words', []):
if b not in self.silenced_words:
self.silenced_words.append(b)
self.update_config({'silenced_words': self.silenced_words, 'silenced_users': self.silenced_users})
def del_silenced(self, **kwargs):
for b in kwargs.get('users', []):
if b in self.silenced_users:
self.silenced_users.remove(b)
for b in kwargs.get('words', []):
if b in self.silenced_words:
self.silenced_words.remove(b)
self.update_config({'silenced_words': self.silenced_words, 'silenced_users': self.silenced_users})
def add_closed(self, users):
for b in users:
if b not in self.closed_users:
self.closed_users.append(b)
self.update_config({'closed_users': self.closed_users})
def del_closed(self, users):
for b in users:
if b in self.closed_users:
self.closed_users.remove(b)
self.update_config({'closed_users': self.closed_users})
def check_for_routines(self):
self.generate_cached_message()
self.wipe_sent_messages()
self.save()
self.refresh()
def wait_for_login(self):
if not self.logged_in:
self.login()
while not self.logged_in:
self.sleep()
def check_name_change(self, username, message):
if not username and message:
usernames = message.split(self.name_change)
if len(usernames) == 2:
username = usernames[1].strip()
return username
def check_for_command(self, username, message):
if self.is_command(message):
if self.is_admin(username):
self.try_command(username, message)
else:
self.send_message(self.deny_message)
return True
return False
def scan(self):
try:
while True:
if not self.logged_in:
self.wait_for_login()
while self.logged_in:
self.sleep(1.5)
self.check_for_routines()
self.check_for_closed()
if self.is_message_present():
username, message = self.capture_message()
if not self.is_bot(username):
if not self.check_for_command(username, message):
if self.is_action(username, message):
username, message = self.capture_action(message)
if self.filter_message(username, message):
self.check_for_triggers(username, message)
self.train_vocabulary(username, message)
elif self.has_user_account():
username = self.check_name_change(username, message)
if not self.is_bot(username):
self.check_for_banned(username, message)
self.check_for_cleared(username, message)
self.check_for_silenced(username, message)
except KeyboardInterrupt:
pass
def shutdown(self):
print('\nSaving and shutting down!\n')
self.browser.quit()
self.force_save()
from extract_table import extract_table
from selenium.webdriver import Chrome
from selenium.webdriver.support.select import Select
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
URL = 'https://wish.wis.ntu.edu.sg/webexe/owa/aus_schedule.main'
options = Options()
options.binary_location = "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
WEBDRIVER_PATH = 'chromedriver.exe'
browser = Chrome(options=options, executable_path=WEBDRIVER_PATH)
browser.get(URL)
select_fr = Select(browser.find_element_by_name('r_course_yr'))
options = browser.find_elements(By.XPATH, '//option')
for x in range(1, len(select_fr.options)):
select_fr.select_by_index(x)
if select_fr.first_selected_option.text != ' ' and len(
select_fr.first_selected_option.text
) != 1 and '--' not in select_fr.first_selected_option.text:
try:
browser.find_element_by_xpath(
"//input[@type='button'][@value='Load Class Schedule']").click(
)
browser.switch_to.window(browser.window_handles[-1])
extract_table(browser.page_source)
browser.close()
browser.switch_to.window(browser.window_handles[0])
except:
try:
def iex_Rtm_import():
# set download directory path
p = {
'download.default_directory':
r'C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\Dumps\iexRtmFile'
}
#add options to browser
opts.add_experimental_option('prefs', p)
browser = Chrome(options=opts)
#maximize browser
browser.maximize_window()
# open the website "https://www.iexindia.com/marketdata/rtm_market_snapshot.aspx"
browser.get('https://www.iexindia.com/marketdata/rtm_market_snapshot.aspx')
# TEST WAIT UNTIL IN SELENIUM
delay = 120 # seconds
try:
myElem = WebDriverWait(browser, delay).until(
EC.presence_of_element_located(
(By.ID, 'ctl00_InnerContent_ddlPeriod')))
except TimeoutException:
print("Loading took too much time!")
# open the dropdown select button "ctl00_InnerContent_ddlPeriod" to select day
iexDrpdwnDam = Select(
browser.find_elements_by_id("ctl00_InnerContent_ddlPeriod")[0])
# select day element of dropdown by index # "yesterday"
iexDrpdwnDam.select_by_index(0)
# click on update report buttton "ctl00_InnerContent_btnUpdateReport"
browser.find_elements_by_id(
"ctl00_InnerContent_btnUpdateReport")[0].click()
# updateReport.click()
# wait until dropdown is opened
dropdownLinks = []
delay = 60 # seconds
try:
myElem = WebDriverWait(browser, delay).until(
EC.presence_of_element_located(
(By.ID,
'ctl00_InnerContent_reportViewer_ctl05_ctl04_ctl00_ButtonImg'
)))
except TimeoutException:
print("Loading took too much time!")
dropdownLinks = browser.find_elements_by_id(
"ctl00_InnerContent_reportViewer_ctl05_ctl04_ctl00_ButtonImg")
# click on different download option button "ctl00_InnerContent_reportViewer_ctl05_ctl04_ctl00_ButtonLink"
dropdownLinks[0].click()
# move all iex files from "C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\iexDamFile" to
# "C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\iexDamFile\Archives"
srcFileLocation = r'C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\Dumps\iexRtmFile'
destFileLocation = r'C:\Users\dheer\Desktop\wrldc\RTM_BROWSER_AUTOMATION\Dumps\iexRtmFile\Archives'
destFileName = "MarketMinute_"
moveFilesToArchive(srcFileLocation, destFileLocation, destFileName)
excelLinks = []
delay = 60 # seconds
try:
myElem = WebDriverWait(browser, delay).until(
EC.presence_of_element_located((By.LINK_TEXT, 'Excel')))
except TimeoutException:
print("Loading took too much time!")
excelLinks = browser.find_elements(By.LINK_TEXT, "Excel")
excelLinks[0].click()
print("iex rtm fetch succesful")
time.sleep(15)
browser.close()
