Example #1
0
    def startMobileDriver(self):

        options = Options()
        options.set_headless(self.useHeadless)
        if self.loadDefaultProfile == True:
            firefoxMobileProfile = webdriver.FirefoxProfile(profile_directory=self.ffProfileDir)
        else:
            firefoxMobileProfile = None
        if self.mobileUA != None:
            firefoxMobileProfile.set_preference("general.useragent.override", self.mobileUA)

        self.firefoxMobileDriver = webdriver.Firefox(
            firefox_profile=firefoxMobileProfile, executable_path=self.driverBinary, firefox_options=options)
        self.mobileRunning = True
        if self.loadCookies == True and self.cookies != None:
            self.firefoxMobileDriver.delete_all_cookies()
            # Loading cookies only works if we are at a site the cookie would work for
            self.getMobileUrl("https://login.live.com")
            for cookie in self.cookies:
                # print("Adding cookie to Firefox Mobile Driver: %s" % str(cookie))
                # new_cookie = {}
                # new_cookie['name'] = cookie['name']
                # new_cookie['value'] = cookie['value']
                try:
                    self.firefoxMobileDriver.add_cookie(cookie)
                except selenium.common.exceptions.InvalidCookieDomainException:
                    contine
Example #2
0
def redeem(codes, headless=True):
    try:
        opts = Options()
        if headless:
            opts.set_headless()
        ffprofile = webdriver.FirefoxProfile(settings.firefox_profile_path)
        browser = webdriver.Firefox(firefox_profile=ffprofile, options=opts)
        browser.get('http://www.marvel.com/redeem')
        redeem_code(browser, codes)
        browser.quit()
    except:
        logging.error('Unable to redeem: %s' % ','.join(codes))
Example #3
0
def EventsList(events_url):
    options = Options()                                                                                         #Grabs the first 4 events from the events page
    options.set_headless(headless=True)
    browser = webdriver.Firefox(firefox_options=options)
    try:
        browser.get(events_url) 
        innerHTML = browser.execute_script("return document.body.innerHTML")
        test = (browser.page_source)
        browser.quit()
    except:
        test = "null"
    try:
        text = test.split('hovercard/event.php?id=')[1]
        text1 = text.split('hovercard/event.php?id=')[0]
        text1 = text1.split('"')[0]
        latest = text1
    except:
        logs.print2("Couldn't extract latest event id")
        latest = "null"
    try:
        text = test.split('hovercard/event.php?id='+text1)[1]
        text2 = text.split('hovercard/event.php?id=')[1]
        text2 = text2.split('hovercard/event.php?id=')[0]
        text2 = text2.split('"')[0]
        first = text2
    except:
        logs.print2("Couldn't extract first event id")
        first = "null"
    try:
        text = test.split('hovercard/event.php?id='+text2)[1]
        text3 = text.split('hovercard/event.php?id=')[1]
        text3 = text3.split('hovercard/event.php?id=')[0]
        text3 = text3.split('"')[0]
        second = text3
    except:
        logs.print2("Couldn't extract second event id")
        second = "null"
    try:
        text = test.split('hovercard/event.php?id='+text3)[1]
        text4 = text.split('hovercard/event.php?id=')[1]
        text4 = text4.split('hovercard/event.php?id=')[0]
        text4 = text4.split('"')[0]
        third = text4
    except:
        logs.print2("Couldn't extract third event id")
        third = "null"
    return (latest,first,second,third)
Example #4
0
    def _get_Firefox(self):

        try:
            bin_path = self.config.get('firefox_binary_path')
            binary = FirefoxBinary(bin_path)
            geckodriver_path = self.config.get('geckodriver_path')
            options = FirefoxOptions()
            profile = webdriver.FirefoxProfile()

            options.add_argument(
                'user-agent={}'.format(self.user_agent))

            if self.browser_mode == 'headless':
                options.set_headless(headless=True)
                #options.add_argument('window-size=1200x600') # optional

            if self.proxy:
                # this means that the proxy is user set, regardless of the type
                profile.set_preference("network.proxy.type", 1)
                if self.proxy.proto.lower().startswith('socks'):
                    profile.set_preference("network.proxy.socks", self.proxy.host)
                    profile.set_preference("network.proxy.socks_port", self.proxy.port)
                    profile.set_preference("network.proxy.socks_version", 5 if self.proxy.proto[-1] == '5' else 4)
                    profile.update_preferences()
                elif self.proxy.proto == 'http':
                    profile.set_preference("network.proxy.http", self.proxy.host)
                    profile.set_preference("network.proxy.http_port", self.proxy.port)
                else:
                    raise ValueError('Invalid protocol given in proxyfile.')

                profile.update_preferences()

            self.webdriver = webdriver.Firefox(firefox_binary=binary, firefox_options=options,
                     executable_path=geckodriver_path, firefox_profile=profile)
            return True

        except WebDriverException as e:
            # reaching here is bad, since we have no available webdriver instance.
            logger.error(e)

        return False
Example #5
0
    outputdir = '/home/firefox/output/'
    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")

    profile = webdriver.FirefoxProfile()
#    USERAGENT = 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36'
#    profile.set_preference("general.useragent.override", USERAGENT)
#    profile.set_preference("permissions.default.image", 2)
#    profile.set_preference('permissions.default.stylesheet', 2)
    profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so', 'false')
    profile.set_preference("network.proxy.ftp", "localhost")
    profile.set_preference("network.proxy.ftp_port", 8080)
    profile.set_preference("network.proxy.http", "localhost")
    profile.set_preference("network.proxy.http_port", 8080)
    profile.set_preference("network.proxy.socks", "localhost")
    profile.set_preference("network.proxy.socks_port", 8080)
    profile.set_preference("network.proxy.ssl", "localhost")
    profile.set_preference("network.proxy.ssl_port", 8080)
    profile.set_preference("network.proxy.type", 1)

    options = Options()
    options.set_headless(headless=True)
    driver = webdriver.Firefox(executable_path='/usr/bin/geckodriver', options=options, firefox_profile=profile)

    try:
        driver.get(url)
        sleep(3)
        print('title:', driver.title)
        driver.save_screenshot(outputdir + 'screenshot-' + timestamp + '.png')
    finally:
       driver.quit()
Example #6
0
    def __init__(self, client="firefox", username="******", proxy=None, command_executor=None, loadstyles=False,
                 profile=None, headless=False, autoconnect=True, logger=None, extra_params=None, chrome_options=None):
        """Initialises the webdriver"""

        self.logger = logger or self.logger
        extra_params = extra_params or {}

        if profile is not None:
            self._profile_path = profile
            self.logger.info("Checking for profile at %s" % self._profile_path)
            if not os.path.exists(self._profile_path):
                self.logger.critical("Could not find profile at %s" % profile)
                raise WhatsAPIException("Could not find profile at %s" % profile)
        else:
            self._profile_path = None

        self.client = client.lower()
        if self.client == "firefox":
            if self._profile_path is not None:
                self._profile = webdriver.FirefoxProfile(self._profile_path)
            else:
                self._profile = webdriver.FirefoxProfile()
            if not loadstyles:
                # Disable CSS
                self._profile.set_preference('permissions.default.stylesheet', 2)
                # Disable images
                self._profile.set_preference('permissions.default.image', 2)
                # Disable Flash
                self._profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
                                             'false')
            if proxy is not None:
                self.set_proxy(proxy)

            options = Options()

            if headless:
                options.set_headless()

            options.profile = self._profile

            capabilities = DesiredCapabilities.FIREFOX.copy()
            capabilities['webStorageEnabled'] = True

            self.logger.info("Starting webdriver")
            self.driver = webdriver.Firefox(capabilities=capabilities, options=options, **extra_params)

        elif self.client == "chrome":
            self._profile = webdriver.ChromeOptions()
            if self._profile_path is not None:
                self._profile.add_argument("user-data-dir=%s" % self._profile_path)
            if proxy is not None:
                self._profile.add_argument('--proxy-server=%s' % proxy)
            if headless:
                self._profile.add_argument('headless')
            if chrome_options is not None:
                for option in chrome_options:
                    self._profile.add_argument(option)
            self.logger.info("Starting webdriver")
            self.driver = webdriver.Chrome(options=self._profile, **extra_params)

        elif client == 'remote':
            if self._profile_path is not None:
                self._profile = webdriver.FirefoxProfile(self._profile_path)
            else:
                self._profile = webdriver.FirefoxProfile()
            capabilities = DesiredCapabilities.FIREFOX.copy()
            self.driver = webdriver.Remote(
                command_executor=command_executor,
                desired_capabilities=capabilities,
                **extra_params
            )

        else:
            self.logger.error("Invalid client: %s" % client)
        self.username = username
        self.wapi_functions = WapiJsWrapper(self.driver, self)

        self.driver.set_script_timeout(500)
        self.driver.implicitly_wait(10)

        if autoconnect:
            self.connect()
Example #7
0
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
opts = Options()
opts.set_headless()
assert opts.headless
browser = webdriver.Firefox(options=opts)
browser.get('https://duckduckgo.com')
search_form = browser.find_element_by_id('search_form_input_homepage')
search_form.send_keys('real python')
search_form.submit()
results = browser.find_elements_by_class_name("result__a")
print(results)
browser.close()
quit()
    def setUp(self):
        options = Options()
        options.set_headless(headless=True)
        self.browser = webdriver.Firefox(firefox_options=options)
        self.browser.implicitly_wait(1)
        # get a user and make sure they are logged in for each test
        self.user = User.objects.get(username='******')
        self.user.profile.account_type = 'artist'
        self.user.save()
        client = Client()
        client.force_login(self.user)
        self.browser.get(self.live_server_url)
        self.browser.add_cookie({
            'name': 'sessionid',
            'value': client.cookies.get('sessionid').value
        })

        def tearDown(self):
            self.browser.quit()

        #User with an artist goes to a venue detail page
        #User clicks requeast to play at venue
        #A requestgigVenue is created with to, from, time and gig_description
        #request is default unconfirmed
        #request shows up in artists dashboard
        #requset can be confirmed or denied by venue owner

        def test_venue_request_create(self):
            self.browser.get(
                self.live_server_url +
                reverse('venue_detail', args=('lT75sSwrUWcVieIYIaQs', )))
            self.browser.find_element_by_id('request_gig_at_venue').click()
            self.assertIn('Request', self.browser.title)
            self.browser.find_element_by_id('id_gig_request_name').send_keys(
                'TestReq5')
            self.browser.find_element_by_id(
                'id_gig_request_description').send_keys('a description')
            self.browser.find_element_by_id('id_gig_request_date').send_keys(
                '01/01/2020')
            self.browser.find_element_by_id('submit').click()
            self.assertIn('created successfully',
                          self.browser.find_element_by_id('messages').text)
            self.assertIn(
                'TestReq5',
                self.browser.find_element_by_id('link_TestReq5').text)

        def test_venue_request_read(self):
            # addfixture to create request
            self.browser.get(self.live_server_url +
                             reverse('artist_dashboard'))
            self.assertIn(
                'James pub',
                self.browser.find_element_by_id('link_GigReqTest3').text)
            self.browser.find_element_by_id('link_GigReqTest3').click()
            self.assertIn(
                'James pub',
                self.browser.find_element_by_id('gig_request_venue').text)

        def test_venue_request_update(self):
            # addfixture to create request
            self.browser.get(self.live_server_url +
                             reverse('artist_dashboard'))
            self.assertIn(
                'GigReqTest3',
                self.browser.find_element_by_id('link_GigReqTest3').text)
            self.browser.find_element_by_id('link_GigReqTest3').click()
            gig_id = self.browser.find_element_by_id('gig_request_id').text
            self.browser.find_element_by_id('update_gig_request').click()
            self.browser.find_element_by_id(
                'id_gig_request_description').clear()
            self.browser.find_element_by_id(
                'id_gig_request_description').send_keys('a new description')
            self.browser.find_element_by_id('submit').click()
            self.browser.find_element_by_id('link_GigReqTest3').click()
            self.assertIn(
                'a new description',
                self.browser.find_element_by_id(
                    'gig_request_description').text)

        def test_venue_request_delete(self):
            self.browser.get(self.live_server_url +
                             reverse('artist_dashboard'))
            self.assertIn('Jim',
                          self.browser.find_element_by_id('artist_name').text)
            self.assertIn(
                'James pub',
                self.browser.find_element_by_id('link_GigReqTest3').text)
            self.browser.find_element_by_id('link_GigReqTest3').click()
            self.browser.find_element_by_id('delete_request').click()
            self.browser.find_element_by_id('submit').click()
            self.assertIn('deleted',
                          self.browser.find_element_by_id('messages').text)
            #logic to see if object delteted

        def test_venue_request_respond(self):
            # addfixture to create request
            self.browser.get(self.live_server_url +
                             reverse('artist_dashboard'))
            self.assertIn(
                'James pub',
                self.browser.find_element_by_id('link_GigReqTest3').text)
            self.browser.find_element_by_id('link_GigReqTest3').click()
            self.browser.find_element_by_id('submit').click()
            self.browser.get(self.live_server_url + reverse('my_gigs'))
            self.assertIn(
                'James pub',
                self.browser.find_element_by_id('link_GigReqTest3').text)
Example #9
0
translistvals = []
for val in kvdict.values():
    translistvals.append(val)

newvals = []
for item in translistvals:
    if '\\n' in item:
        item = item.split('\\n')
    newvals.append(item)

sepdict = {}
for (k, v) in zip(translistkeys, newvals):
    sepdict[k] = v

options = Options()
options.set_headless()
firefox_profile = webdriver.FirefoxProfile()
firefox_profile.set_preference('permissions.default.image', 2)
firefox_profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
                               False)
assert options.headless
driver = webdriver.Firefox(firefox_options=options,
                           firefox_profile=firefox_profile)
driver.get("https://translate.google.co.uk/#en/" + langcode + "/")

newrefvals = []
itemlist = list(sepdict.items())
for key, value in sepdict.items():
    x = False
    if (type(value) is list):
        tempvals = []
Example #10
0
# from selenium.webdriver.support.ui import WebDriverWait
# from selenium.webdriver.support import expected_conditions as EC
import time

#4) stadium name
#	https://en.wikipedia.org/wiki/List_of_national_stadiums
#	stadium_image_url
#	https://en.wikipedia.org/wiki/Estadio_Monumental_Antonio_Vespucio_Liberti

CITY = 3
STADIUM_NAME = 4  #CLICKABLE
CAPACITY = 5
BUILT_DATE = 6

opts = Options()
opts.set_headless = True
driver = webdriver.Firefox(options=opts)
driver.get('http://www.worldstadiums.com/')

time.sleep(3)

#click on the continent
continent_buttons = driver.find_elements_by_xpath("//td[@bgcolor='#e6e6ff']/a")
continent_buttons[3].click()

time.sleep(5)

#driver_1 = driver_1.page_source
#latest_window = driver.window_handles[1]
#driver.switch_to(window(latest_window))
#source_code = driver.page_source
Example #11
0
 def setUpClass(cls):
     super().setUpClass()
     opts = Options()
     opts.set_headless()
     cls.browser = webdriver.Firefox(options=opts)
     cls.browser.set_window_size(1024, 768)
 def setUp(self):
     options = Options()
     options.set_headless(headless=True)
     self.browser = webdriver.Firefox(firefox_options=options)
     self.browser.implicitly_wait(1)
     self.user = User.objects.get(username='******')
Example #13
0
def initialize():
    global selenium
    if not selenium:
        opts = Options()
        opts.set_headless()
        selenium = Firefox(options=opts)
Example #14
0
 def __init__(self,start_url=START_URL):
     opts = Options() # call optoins for Firefox browser
     opts.set_headless()
     assert opts.headless # set hidden mode for browser
     self.browser = webdriver.Firefox(options=opts) # run browser
     self.browser.get(start_url) # open start_url
Example #15
0
def getCollections():

    #counter for tallying collections
    counter = 0

    #list to store all the JSON data of collections.
    collections = []

    #options for headless mode
    options = Options()
    options.set_headless(headless=True)

    #open browser
    driver = selenium.webdriver.Firefox(firefox_options=options,
                                        executable_path=r'./geckodriver')

    #make url varaible to hold url
    url = "https://www.nasa.gov/multimedia/imagegallery/iotd.html"

    #load url
    driver.get(url)

    #Yamini Maddelawait until the button loads to load more images
    #try:
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "trending")))

    #once the button loads, click it 16 times
    #	i =0
    #	while i <= 15:
    #      		driver.find_element_by_xpath('//*[@id="trending"]').click()
    #     		i += 1
    #slow down the load to insure button loads correctly
    #    		time.sleep(1)

    #click on the first card or picture
    driver.find_element_by_class_name('gallery-card:first-child').click()

    i = 0
    while i <= 3:

        #get the hreh link for current page
        date_url = driver.find_element_by_partial_link_text('View Image')

        #collection object
        collection = {}
        collection["Creator"] = "Nasa image of the Day"
        collection["URL"] = "https://nasa.gov"
        collection["ReferenceURL"] = url

        #new dictionary for contact information
        contact_JSON = {}
        contact_JSON["Name"] = "Robert Nemiroff"
        contact_JSON["Email"] = "*****@*****.**"
        contact_JSON["Telephone"] = "1-906-487-2198"
        contact_JSON["Address"] = "1400 Townsend Drive"
        contact_JSON["City"] = "Houghton"
        contact_JSON["StateProvince"] = "Michigan"
        contact_JSON["PostalCode"] = "49931"
        contact_JSON["Country"] = "USA"

        #add contact_JSON object to collection Object
        collection["Contact"] = contact_JSON

        #get the description
        description = driver.find_element_by_tag_name('p')
        collection["Description"] = description.text

        #get the rest of the image collection
        get_json(date_url.get_attribute("href"), collection)

        #add current collection JSON object to collections list
        collections.append(collection)

        #after collectiong, click on the next button for next picture
        driver.find_element_by_class_name('flex-next').click()

        i += 1

    #close the driver
    driver.close()

    return {"collections": collections, "count": counter}
Example #16
0
def get_page_with_selenium(query, w=True):
    # COMMENT
    """
    geckodriver&firefox: https://elements.heroku.com/buildpacks/evosystem-jp/heroku-buildpack-firefox
    add RedosToGo on Heroku
    :param query:
    :param w:
    :return:
    """
    yandex_dict = {}

    opts = Options()
    opts.set_headless()
    # binary = FirefoxBinary('/app/vendor/firefox/firefox')
    # driver = Firefox(options=opts, firefox_binary=binary, executable_path='/app/vendor/geckodriver/geckodriver')
    # driver = Firefox(options=opts, firefox_binary=binary)
    driver = Firefox(options=opts)
    driver.wait = WebDriverWait(driver, 5)
    driver.get('https://www.yandex.ru')
    html = driver.page_source
    if w:
        print(1)
        with open('index.html', 'w') as f:
            f.write(html)
    # try:
    # #
    # #     # box = driver.find_element_by_id('text')
    # #
    #     box = driver.wait.until(EC.presence_of_element_located(
    #         (By.ID, 'text'),
    #     ))
    # #     print(12)
    # #     button = driver.find_element_by_class_name('suggest2-form__button')
    #     button = driver.wait.until(EC.presence_of_element_located(
    #         (By.CLASS_NAME, 'suggest2-form__button')
    #     ))
    #     box.send_keys(query)
    #     button.click()
    # except TimeoutException:
    #     print('Box or Button didnt find')

    sent = '"' + query[0] + '"'
    box = driver.find_element_by_name('text')
    # button = driver.find_element_by_class_name('suggest2-form__button')
    # button = driver.find_element_by_class_name('button mini-suggest')
    button = driver.find_element_by_class_name('search2__button')
    box.send_keys(sent)
    button.click()
    yandex_dict[sent] = driver.page_source

    for sent in query[1:]:
        close = driver.find_element_by_class_name('input__clear')
        close.click()
        box = driver.find_element_by_name('text')
        button = driver.find_element_by_class_name('websearch-button')
        sent = '"' + sent + '"'
        box.send_keys(sent)
        button.click()
        yandex_dict[sent] = driver.page_source

    html = driver.page_source

    driver.close()
    if w:
        print(1)
        with open('index.html', 'w') as f:
            f.write(html)

    return yandex_dict
Example #17
0
def getFloData(outFileDir):
    profile=FirefoxProfile()
    profile.set_preference('browser.download.folderList', 2)
    profile.set_preference('browser.download.manager.showWhenStarting', False)
    profile.set_preference('browser.helperApps.neverAsk.saveToDisk', 'text/csv')
    profile.set_preference('browser.download.dir', outFileDir)

    opts = Options()
    opts.set_headless()
    assert opts.headless

    browser = Firefox(options=opts, firefox_profile=profile)
    browser.get('https://user.meetflo.com/login')

    assert(browser.title == 'Flo - My Account')
    
    FloUser = os.environ['FLO_USER']
    FloPW = os.environ['FLO_PW']

    login_form=browser.find_elements_by_class_name('form-control')
    login_form[0].send_keys(FloUser)
    login_form[1].send_keys(FloPW)
    login_button=browser.find_elements_by_class_name('btn')
    login_button[0].click()

    try:
        element = WebDriverWait(browser, 10).until(
            EC.title_is('Flo - Home'))
    finally:
        pass
        
    browser.get('https://user.meetflo.com/usage')

    try:
        element = WebDriverWait(browser, 10).until(
            EC.title_is('Flo - Usage'))
    finally:
        pass

    assert(browser.title == 'Flo - Usage')

    dataDownload = browser.find_element_by_class_name('data-download')
#    pdb.set_trace()

    # why this sleep should be necessary is a mystery
    time.sleep(2)
    
    dataDownloadButton = dataDownload.find_element_by_class_name('dropdown-toggle')
    dataDownloadButton.click()
    
    csv_button = None
    dropdownItemList=browser.find_elements_by_class_name('dropdown-item')
    for (i,item) in enumerate(dropdownItemList):
        if DEBUG:
            print(i, item.get_attribute('outerHTML'))
            print(item.text)
        if item.text=='as CSV':
            csv_button = item

    assert(csv_button.text=='as CSV')

    csv_button.click()

    browser.close()
Example #18
0
 def __init__(self):
     options = Options()
     options.set_headless(headless=True)
     self.driver = webdriver.Firefox(firefox_options=options)
     self.driver.set_page_load_timeout(60)
def retrieve_squad_national_team(confederation):
    if confederation == 'UEFA':

        opts = Options()
        opts.set_headless = True
        driver = webdriver.Firefox(options=opts)
        driver.get(urls['url_1'])

        #	vereinprofil_tooltip tooltipstered
        POSITION_TEAM = 0
        NAME_TEAM = 1
        TOTAL_VALUE_TEAM = 4
        CONFEDERATION_TEAM = 5

        #country_buttons = driver.find_elements_by_xpath("//a[@class='vereinprofil_tooltip tooltipstered']")
        #country_buttons = driver.find_elements_by_xpath("//td[@class='hauptlink']")

        #26-50

        pager = driver.find_elements_by_xpath(
            "//div[@class='pager']/ul[@id='yw2']/li/a")

        time.sleep(3)
        #pager[PAGE_2].click()

        for page_number in range(0, 9):
            #if page_number == 0 or page_number == 1:
            driver.execute_script("arguments[0].click();", pager[page_number])
            #else:
            #	driver.execute_script("arguments[0].click();", pager[page_number + 2])

            time.sleep(3)

            pager = driver.find_elements_by_xpath(
                "//div[@class='pager']/ul[@id='yw2']/li/a")
            #print(pager[page_number].get_attribute('outerHTML'))

            table_teams = driver.find_elements_by_xpath("//tbody/tr")

            # PAGE 1: 1-25
            #print('len:' + str(len(table_teams)))
            number_of_teams_on_the_page = len(table_teams)

            for k in range(number_of_teams_on_the_page - 1,
                           number_of_teams_on_the_page):

                #print('table_teams = ' + str(table_teams[k].get_attribute('innerHTML')))
                team = table_teams[k].find_elements_by_tag_name('td')

                #print(team[NAME].get_attribute('innerHTML'))

                #print('position = ' + str(rows[POSITION].get_attribute('innerHTML')))
                print('position = ' + str(team[POSITION_TEAM].text))
                print('-')

                #print('******' + str(team[POSITION].get_attribute('outerHTML')))
                name = team[NAME_TEAM].find_elements_by_tag_name('a')
                #print('name = ' + str(name))
                #print('************** ' + str(name[0].get_attribute('innerHTML')))
                #print('name = ' + str(rows[NAME].get_attribute('innerHTML')))
                print('name = ' + str(name[1].get_attribute('innerHTML')))
                print('-')

                print('total_value = ' +
                      str(team[TOTAL_VALUE_TEAM].get_attribute('innerHTML')))
                print('-')

                print('confederation = ' +
                      str(team[CONFEDERATION_TEAM].get_attribute('innerHTML')))

                #click on team's name
                driver.execute_script("arguments[0].click();", name[1])

                time.sleep(3)

                #######################################################################
                #							squad data
                #######################################################################

                #market_value = driver.find_elements_by_xpath("//div[@class='dataMarktwert']/a/span[@class='waehrung']")
                # market_value = driver.find_elements_by_xpath("//div[@class='dataMarktwert']/a")
                # print('market_value = ' + str(market_value[0].text))

                # 							formation
                formation_row = driver.find_elements_by_xpath(
                    "//div[@class='large-7 aufstellung-vereinsseite columns small-12 unterueberschrift aufstellung-unterueberschrift']"
                )
                #print(formation_row[0])
                formation_row = formation_row[0].get_attribute('innerHTML')
                formation_row = formation_row.rstrip().lstrip()
                #print('formation row: ' + str(formation_row))
                formation = formation_row.split(' ')  #
                # formation = formation[2]
                print('formation: ' + formation[2])

                # 							label substitutes and players
                squad = driver.find_elements_by_xpath(
                    "//div[@class='large-7 columns small-12 aufstellung-vereinsseite']/div[@style='position: absolute; top: 0; bottom: 0; left: 0; right: 0;']/div[@class='aufstellung-spieler-container']"
                )
                #squad = driver.find_elements_by_xpath("//div[@class='large-7 columns small-12 aufstellung-vereinsseite']")
                #print("squad: " + squad[0].get_attribute('innerHTML'))
                #squad =

                counter = 0

                name_and_numbers = []
                dictionary = {}

                for s in squad:
                    # print(str(counter) + ") " + str(s.text))
                    st = s.text
                    name_number = st.split('\n')

                    number = name_number[0]
                    name = name_number[1]

                    dictionary = {}
                    dictionary['number'] = number
                    dictionary['name'] = name

                    name_and_numbers.append(dictionary)  #

                    counter += 1

                #print(name_and_numbers)
                #print(name_and_numbers)

                print("************************Squad*******************")
                for name_and_number in name_and_numbers:
                    print(
                        str(name_and_number['number']) + "  " +
                        str(name_and_number['name']))

                #######################################################################

                #######################################################################
                #							substitutes data
                #######################################################################
                substitutes = driver.find_elements_by_xpath(
                    "//div[@class='large-5 columns small-12 aufstellung-ersatzbank-box aufstellung-vereinsseite']/table[@class='ersatzbank']/tbody/tr"
                )
                name_and_numbers_sub = []
                dictionary_sub = {}
                print(
                    "***************************Substitutes***********************"
                )
                for subs in substitutes:
                    sub = subs.find_elements_by_tag_name('td')
                    #print(str(sub[0].text) + "  " + str(sub[1].text))

                    # st = sub.text
                    # name_number = st.split('\n')

                    sub_number = sub[0].text
                    sub_name = sub[1].text

                    # print(sub_number)
                    # print(sub_name)

                    dictionary_sub = {}
                    dictionary_sub['number'] = sub_number
                    dictionary_sub['name'] = sub_name
                    name_and_numbers_sub.append(dictionary_sub)  #

                    # print(sub[0].text)
                    # print(sub[1].text)
                    # print('-------------------------------')

                    #!!! last one is the manager, so don't append it to the dictionary_sub
                #print(name_and_numbers_sub)
                for name_and_number_sub in name_and_numbers_sub:
                    number = name_and_number_sub['number']
                    name = name_and_number_sub['name']
                    print(str(number) + "  " + str(name))

                #######################################################################
                #							manager data
                #######################################################################
                #slider-list
                table_managers = driver.find_elements_by_xpath(
                    "//div[@class='large-4 columns']/div[@class='box box-slider']/div[@class='clearer']"
                )
                table_managers = driver.find_elements_by_xpath(
                    "//div[@class='container-inhalt']/div[@class='container-hauptinfo']/a"
                )

                manager_name = table_managers[0].get_attribute('innerHTML')  #
                print("manager_name: " + str(manager_name))

                driver.execute_script("arguments[0].click();",
                                      table_managers[0])

                time.sleep(4)

                manager_info = driver.find_elements_by_xpath(
                    "//div[@id='trainer_head']/div[@class='large-12 columns']/div[@class='dataHeader']/div[@class='dataContent']"
                )
                manager_info = manager_info[0].find_elements_by_tag_name(
                    'span')

                # for info in manager_info:
                # 	print(str(counter) + ") " + str(info.get_attribute('innerHTML')))
                # 	counter += 1

                manager_date_of_birth = manager_info[1].get_attribute(
                    'innerHTML')
                manager_place_of_birth = manager_info[4].get_attribute(
                    'innerHTML')
                manager_citizenship = manager_info[7].get_attribute(
                    'innerHTML')
                manager_preferred_formation = manager_info[17].get_attribute(
                    'innerHTML')

                manager_date_of_birth = re.sub(' +', ' ',
                                               manager_date_of_birth)
                m = manager_date_of_birth.split()

                manager_date_of_birth_month = m[0]  #
                manager_date_of_birth_day = m[1].replace(',', '')  #
                manager_date_of_birth_year = m[2]  #
                manager_date_of_birth_age = m[3].replace('(',
                                                         '').replace(')',
                                                                     '')  #

                print("manager_date_of_birth: ")
                print("	month: " + str(manager_date_of_birth_month))
                print("	day: " + str(manager_date_of_birth_day))
                print("	year: " + str(manager_date_of_birth_year))
                print("	age: " + str(manager_date_of_birth_age))

                print("manager_place_of_birth: " + str(manager_place_of_birth))
                print("manager_citizenship: " + str(manager_citizenship))
                print("manager_preferred_formation: " +
                      str(manager_preferred_formation))
                #print('manager_info: ' + manager_info[0].get_attribute('innerHTML'))

                # get manager's photo
                manager_info = driver.find_elements_by_xpath(
                    "//div[@id='trainer_head']/div[@class='large-12 columns']/div[@class='dataHeader']/div[@class='dataBild']"
                )
                print('************************Photo')
                manager_photo = manager_info[0].find_elements_by_tag_name(
                    'img')[0].get_attribute('src')
                print("manager_photo: " + str(manager_photo))
                #print(manager_info[0].get_attribute('innerHTML'))

                driver.back()

                time.sleep(4)
                ######################################################################

                #table_players = driver.find_elements_by_xpath("//div[class='responsive-table']/div[@class='grid-view']/table[@class='items']/tbody/tr")
                table_players = driver.find_elements_by_xpath(
                    "//table[@class='items']/tbody/tr")
                squad_size = len(table_players)

                #print('***** ' + str(len(table_players)))

                ######################################################################
                ######################################################################

                for i in range(squad_size - 1, squad_size):
                    #print(i)
                    print('------------------------------------------')
                    print('------------------------------------------')
                    print('------------------------------------------')

                    player = table_players[i].find_elements_by_tag_name('td')

                    NATIONAL_TEAM_NUMBER = 0
                    POSITION = 4
                    NAME = 5
                    MARKET_VALUE = 8

                    national_team_number = player[NATIONAL_TEAM_NUMBER].text
                    position = player[POSITION].get_attribute('innerHTML')
                    name = player[NAME].get_attribute('innerHTML')
                    market_value = player[MARKET_VALUE].text

                    print('number: ' + str(national_team_number))
                    print('position: ' + str(position))
                    print('name: ' + str(name))
                    print('market value: ' + str(market_value))

                    player_link = player[1].find_elements_by_xpath(
                        "//table[@class='inline-table']/tbody/tr/td[@class='hauptlink']/div/span/a"
                    )
                    #print('link: ' + str(player_link[0].get_attribute('href')))

                    #print(player[1].get_attribute('outerHTML'))
                    driver.execute_script("arguments[0].click();",
                                          player_link[2 * i])

                    time.sleep(4)

                    #######################################################################
                    #							player data
                    #######################################################################
                    player_data = driver.find_elements_by_xpath(
                        "//div[@class='row']/div[@class='large-12 columns']/div[@class='dataHeader dataExtended']/div"
                    )

                    #print(player_data[2].get_attribute('outerHTML'))
                    #player_data[2].find_elements_by_tag_name('img')

                    #					 player image
                    player_image = player_data[2].find_elements_by_tag_name(
                        'img')[0].get_attribute('src')  #
                    #print(player_data[2].find_elements_by_tag_name('img')[0].get_attribute('src'))
                    print('player_image: ' + str(player_image))

                    #####################################################################
                    # 					player date_of_birth
                    player_info = player_data[1].find_elements_by_xpath(
                        "//div[@class='dataBottom']")
                    player_dob = player_info[0].find_elements_by_tag_name(
                        'span')

                    player_date_of_birth = player_dob[1].get_attribute(
                        'innerHTML').rstrip().lstrip()
                    player_date_of_birth = re.sub(' +', ' ',
                                                  player_date_of_birth)
                    p = player_date_of_birth.split()

                    player_date_of_birth_month = p[0]  #
                    player_date_of_birth_day = p[1].replace(',', '')  #
                    player_date_of_birth_year = p[2]  #
                    player_date_of_birth_age = p[3].replace('(', '').replace(
                        ')', '')  #

                    print('month: ' + player_date_of_birth_month)
                    print('day: ' + player_date_of_birth_day)
                    print('year: ' + player_date_of_birth_year)
                    print('age: ' + player_date_of_birth_age)
                    #print(player_date_of_birth)
                    #print(player_dob[1].get_attribute('innerHTML').rstrip().lstrip())

                    #####################################################################
                    # 					player place_of_height
                    #print(player_info[0].get_attribute('innerHTML'))
                    player_height = player_info[0].find_elements_by_tag_name(
                        'span')

                    if player_height[8].get_attribute(
                            'innerHTML') == 'Height:':
                        height = player_height[9].get_attribute('innerHTML')  #
                        print('height: ' + str(height))
                    #print(player_info[0])
                    #player_height = player_info[0]

                    #####################################################################
                    # 					player total value
                    # player_info = player_data[4].find_elements_by_tag_name('a')

                    # #player_total_value = player_info[0].find_elements_by_tag_name('span')
                    # #player_total_value = player_info[0].get_attribute('innerHTML')

                    # player_total_value = player_info[0].text
                    # player_tot_val_list = player_total_value.split(' ')
                    # player_total_value = player_tot_val_list[0].split('\n')
                    # player_total_value = player_total_value[0]						#
                    # print('total_value: ' + str(player_total_value))
                    #print('*** ' + str(player_total_value[1].get_attribute('innerHTML')))

                    #####################################################################
                    # 					place of birth
                    player_info = player_data[1].find_elements_by_xpath(
                        "//div[@class='dataBottom']/div")

                    player_place_of_birth = player_info[
                        0].find_elements_by_tag_name('span')

                    #if player_place_of_birth[3]
                    if player_place_of_birth[2].get_attribute(
                            'innerHTML') == 'Place of birth:':
                        player_place_of_birth_city = player_place_of_birth[
                            4].get_attribute('innerHTML')  #
                        print('place_of_birth: ' +
                              str(player_place_of_birth_city))

                    driver.back()

                    time.sleep(4)

                    table_players = driver.find_elements_by_xpath(
                        "//table[@class='items']/tbody/tr")

                print('********************************')

                driver.back()

                time.sleep(4)

                #pager = driver.find_elements_by_xpath("//div[@class='pager']/ul[@id='yw2']/li/a")
                #print(pager[page_number].get_attribute('outerHTML'))

                table_teams = driver.find_elements_by_xpath("//tbody/tr")

                #team = table_teams[k + 1].find_elements_by_tag_name('td')
                ######################################################################
                ######################################################################

            driver.back()

            time.sleep(4)

            pager = driver.find_elements_by_xpath(
                "//div[@class='pager']/ul[@id='yw2']/li/a")

            time.sleep(3)
Example #20
0
def main():
    """Entrypoint for blobtools view."""
    args = docopt(__doc__)
    loc = "%s/%s/dataset/%s" % (args['--host'], args['--prefix'],
                                args['DATASET'])
    qstr = "staticThreshold=Infinity"
    qstr += "&nohitThreshold=Infinity"
    qstr += "&plotGraphics=svg"
    if args['--format'] == 'svg':
        qstr += "&svgThreshold=Infinity"
    shape = 'square'
    for param in args['--param']:
        qstr += "&%s" % str(param)
        key, value = param.split('=')
        if key == 'plotShape':
            shape = value

    timeout = int(args['--timeout'])

    outdir = os.path.abspath(args['--out'])
    os.makedirs(Path(outdir), exist_ok=True)

    profile = webdriver.FirefoxProfile()
    profile.set_preference('browser.download.folderList', 2)
    profile.set_preference('browser.download.manager.showWhenStarting', False)
    profile.set_preference('browser.download.dir', outdir)
    profile.set_preference('browser.download.lastDir', args['--out'])
    profile.set_preference(
        'browser.helperApps.neverAsk.saveToDisk',
        'image/png, image/svg+xml, text/csv, text/plain, application/json')

    options = Options()
    options.set_headless(headless=False)
    display = Display(visible=0, size=(800, 600))
    display.start()
    driver = webdriver.Firefox(options=options, firefox_profile=profile)
    try:
        view = args['--view'][0]
        if args['--preview']:
            qstr += '#Filters'
        url = "%s/%s?%s" % (loc, view, qstr)
        print("Loading %s" % url)
        try:
            driver.get(url)
        except Exception as err:
            print(err)

        for next_view in args['--view']:
            if next_view != view:
                view = next_view
                url = "%s/%s?%s" % (loc, view, qstr)
                print("Navigating to %s" % url)
                try:
                    driver.get(url)
                except Exception as err:
                    print(err)
            for fmt in args['--format']:
                file = "%s.%s" % (args['DATASET'], view)
                if view == 'blob':
                    file += ".%s" % shape
                elif view == 'busco':
                    view = "all_%s" % view
                    if fmt not in ('csv', 'json'):
                        fmt = 'json'
                file += ".%s" % fmt
                print("Fetching %s" % file)
                el_id = "%s_save_%s" % (view, fmt)
                print("waiting for element %s" % el_id)
                unstable = True
                while unstable:
                    try:
                        element = WebDriverWait(driver, timeout).until(
                            EC.visibility_of_element_located((By.ID, el_id)))
                        element.click()
                        unstable = False
                        file_name = "%s/%s" % (outdir, file)
                        print("waiting for file '%s'" % file_name)
                        file_ready(file_name)
                    except Exception as err:
                        time.sleep(1)

        for preview in args['--preview']:
            print("Creating %s preview" % preview)
            for fmt in args['--format']:
                el_id = "%s_preview_save_%s" % (preview, fmt)
                file = "%s.%s.preview.%s" % (args['DATASET'], preview, fmt)
                try:
                    element = WebDriverWait(driver, timeout).until(
                        EC.visibility_of_element_located((By.ID, el_id)))
                    element.click()
                    file_name = "%s/%s" % (outdir, file)
                    print("waiting for file '%s'" % file_name)
                    file_ready(file_name)
                except Exception as err:
                    print(err)
        driver.close()
    except Exception as err:
        print(err)
        driver.close()
Example #21
0
 def driver(self):
     options = Options()
     options.set_headless(headless=True)
     return webdriver.Firefox(firefox_options=options)
Example #22
0
 def __init__(self):
     firefox_options = Options()
     firefox_options.set_headless()
     self.browser = Firefox(options=firefox_options)
     self.browser = webdriver.Firefox()
     self.browser.get("https://mbasic.facebook.com/login")
Example #23
0
print("Initializing...")
import os
import wikipedia
import datetime
from selenium import webdriver as wd
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.firefox.options import Options
from webdriver_manager.firefox import GeckoDriverManager
from selenium.webdriver.common.action_chains import ActionChains
import enchant
print("Opening Browser For Testing...")
driver = wd.Firefox(executable_path=GeckoDriverManager().install())
os.system("clear")
# driver.close()
opt = Options()
opt.set_headless()
assert opt
headless_driver = wd.Firefox(executable_path=GeckoDriverManager().install(),options=opt)
# headless_driver.close()
print("Looking Good. Clearing Terminal.")
os.system("clear")
dictionary = enchant.Dict("en_UK")

def search_app(channel=""):
    channel=input("Which Video do you want to view :")
    driver.get("https://www.youtube.com/")
    search_ele = driver.find_element_by_name("search_query")
    search_ele.send_keys(channel,Keys.ENTER)

def searchQuestion(query):
    driver.get("https://duckduckgo.com/")
Example #24
0
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

options = Options()
options.set_headless(headless=False)
driver = webdriver.Firefox(firefox_options=options)
is_last = False
nr_art = 0
nr_rev = 0
pagina = 'https://www.ncbi.nlm.nih.gov/pubmed/?term=Br+J+Anaesth.+2018+Jul'

#Para max_resultados()
id_maxres = "Display"
id_index = 2


def obter_pagina(pagina):
    driver.get(pagina)
    print("Headless Firefox Initialized")


def max_resultados(id_maxres, id_index):
    lista = driver.find_elements_by_id(id_maxres)
    lista[id_index].click()
    driver.find_element_by_id("ps200").click()


def sacar():
 def setUp(self):
     options = Options()
     options.set_headless(headless=True)
     self.browser = webdriver.Firefox(firefox_options=options)
     self.browser.implicitly_wait(1)
def load_page(url):
    # Create a filename for the output files
    file_name = url.lower().replace("http://", "").replace(
        "https://",
        "").replace("www.", "").split("/")[0].replace("-",
                                                      "_").replace(".", "_")

    #Initialize a server/proxy for loading the page
    server = Server(browsermob_location)
    server.start()
    profile = webdriver.FirefoxProfile()
    #profile.accept_untrusted_certs = True
    #profile.set_preference("general.useragent.override", "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:84.0) Gecko/20100101 Firefox/84.0")
    opts = Options()
    opts.set_headless()
    assert opts.headless
    driver = webdriver.Firefox(options=opts,
                               firefox_profile=profile,
                               executable_path=geckodriver_location)

    # Try to load the page
    try:
        driver.get(url)
    except Exception as e:
        print("Error during load of {}: {}".format(url, str(e).strip()))
        # Be sure you try HTTP if HTTPS fails
        if "https://" not in url:
            url = url.replace("http://", "https://")
            driver.get(url)

    # Parse the HTML
    try:
        print("Getting HTML")
        with open('{}/{}.html'.format(output_dir, file_name),
                  'w+',
                  encoding='utf-8') as save_html:
            save_html.write(str(driver.page_source))
    except Exception as e:
        print("Error getting page source: {}".format(str(e)))

    # Get a screenshot with static size as pages will have different formats.
    try:
        print("Getting Screenshot")
        driver.set_window_size(1920, 2000)
        driver.save_screenshot('{}/{}.png'.format(output_dir, file_name))
    except Exception as e:
        print("Error getting screenshot: {}".format(str(e)))

    # Get the har data (e.g. resources it loads)
    try:
        print("Getting HAR data")
        proxy = server.create_proxy()
        profile.set_proxy(proxy.selenium_proxy())
        driver = webdriver.Firefox(options=opts,
                                   firefox_profile=profile,
                                   executable_path=geckodriver_location)
        driver.get(url)
        proxy.new_har(url, options={'captureHeaders': True})
        har_data = json.dumps(proxy.har, indent=4)
        with open('{}/{}.har'.format(output_dir, file_name), 'w+') as save_har:
            save_har.write(str(har_data))
    except Exception as e:
        print("Error getting har: {}".format(str(e).strip()))

    # Kill everything...
    server.stop()
    driver.quit()

    print("Done!")
Example #27
0
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
import os
import time

#open Firefox browser headless
opts = Options()
opts.set_headless(headless=True)
assert opts.headless

# no log file setting
browser = webdriver.Firefox(options=opts, service_log_path=os.devnull)
# service_log_path = os.devnull makes no geckodriver.log file

url = 'https://www.google.com.tw/'
browser.get(url)
time.sleep(3)

browser.quit()
Example #28
0
def main():
    p = subprocess.Popen(["darkreader/host_with_flask.py"],
                         stdout=sys.stdout,
                         stderr=sys.stderr)
    # while True:
    #     stdout = str(p.stdout.readline(), encoding="UTF-8")
    #     print("stdout:", stdout)
    #     if "* Running on http://" in stdout:
    #         break
    # url = "http://" + stdout.split("http://")[1].split("/")[0]
    url = "http://127.0.0.1:5687/"
    # print(stdout, url)
    time.sleep(4)
    # print("received:", requests.get(url).text)

    options = Options()
    options.set_headless(headless=True)
    driver = webdriver.Firefox(firefox_options=options)
    js = """
    var callback = arguments[0];
    DarkReader.exportGeneratedCSS().then(function(result){callback(result);});
    """

    # Generate darkreader css for index.html:
    driver.get(url)
    time.sleep(3)
    darkreader_generated_css = driver.execute_async_script(js).replace(
        url, "https://phseiff.com/")
    with open("index.html.darkreader.css", "w") as f:
        f.write(darkreader_generated_css)
    with open("index.html", "r") as f:
        content = f.read()
        content = content.replace(
            """
    <script type="text/javascript" src="darkreader/darkreader.min.js"></script>
    <script>
        DarkReader.setFetchMethod(window.fetch);
        DarkReader.enable({ // <-- always use darkmode instead of, like previously, adapting to the system.
            brightness: 100,
            contrast: 90,
            sepia: 10
        });
    </script>""", "<style>" + css_html_js_minify.css_minify(
                darkreader_generated_css.split("/* Modified CSS */")[0]) +
            "</style>")
        content = content.replace(
            """
    <!-- Ensure dark reader is executed again after we updated the essays using javascript. -->
    <script>
        DarkReader.disable();
        DarkReader.enable({ // <-- always use darkmode instead of, like previously, adapting to the system.
            brightness: 100,
            contrast: 90,
            sepia: 10
        });
    </script>""",
            """<link type="text/css" rel="stylesheet" href="/index.html.darkreader.min.css">"""
        )
    with open("index.html", "w") as f:
        f.write(content)

    # Generate darkreader css for github card:
    driver.get(url + "//github-card/response.html")
    darkreader_generated_css = driver.execute_async_script(js).replace(
        url, "https://phseiff.com")
    with open("github-card/response.html.darkreader.css", "w") as f:
        f.write(darkreader_generated_css.split("/* Modified CSS */")[1])
    with open("github-card/response.html", "r+") as f:
        content = f.read()
        content = content.replace(
            """
<script type="text/javascript" src="../darkreader/darkreader.min.js"></script>
<script>
    DarkReader.setFetchMethod(window.fetch)
    DarkReader.enable({
        brightness: 100,
        contrast: 90,
        sepia: 10
    });
</script>""",
            """<link type="text/css" rel="stylesheet" href="/github-card/response.html.darkreader.min.css">"""
        )
    with open("github-card/response.modified.html", "w") as f:
        f.write(content)

    print("got all but error page!")
    # Generate css for 404 error page:
    driver.get(url + "//404-raw.html")
    darkreader_generated_css = driver.execute_async_script(js).replace(
        url, "https://phseiff.com")
    with open("404.html.darkreader.css", "w") as f:
        f.write(darkreader_generated_css)
    with open("404-raw.html", "r") as f:
        with open("404.html", "w") as f2:
            f2.write(f.read().replace(
                """
            <script type="text/javascript" src="/darkreader/darkreader.min.js"></script>
            <script>
                DarkReader.setFetchMethod(window.fetch);
                DarkReader.enable({
                    brightness: 100,
                    contrast: 90,
                    sepia: 10
                });
            </script>""",
                ("""<link type="text/css" rel="stylesheet" href="/404.html.darkreader.min.css">"""
                 if False else
                 """<link type="text/css" rel="stylesheet" href="/index.html.darkreader.min.css">"""
                 )))

    p.kill()
    driver.close()
Example #29
0
def scrape_dea(zips):
    '''
        Purpose: Function that will scrape dropbox locations for all zip 
                 codes contained in the list `zips`.
    
        Input:   zips (list): list of zip codes
        
        Output:  CSV file containing all unique dropbox locations for the 
                 zip codes specified in `zips`
    '''
    # Open a Headless Firefox web browser and direct it to the DEA's dropbox
    #   search page
    options = Options()
    options.set_headless(headless=True)
    browser = webdriver.Firefox(firefox_options=options)
    #    browser = webdriver.Firefox()
    browser.get('https://apps.deadiversion.usdoj.gov/SEARCH-NTBI')
    browser.implicitly_wait(10)

    # final storage container for dropbox locations
    dropboxList = []

    count = 0
    # For every zip code in the US, run the dropbox location search on the site
    for code in zips:
        status = ''
        status = scrape_page(browser, code)

        # If we find a bad zip code or no dropbox locations are found in a
        #   zip, skip to the next zip code
        if status == 'NONE_FOUND' or status == 'BAD_ZIP':
            browser.get('https://apps.deadiversion.usdoj.gov/SEARCH-NTBI')
            continue
        else:
            # For every column in a row in the dropbox location table, grab
            #   the data and place it in the list `rowList`.  After each
            #   row is read, add that data to the master list `dropboxList`.
            for tr in status.findAll('tr')[2:-1]:
                rowList = []
                for td in tr.findAll('td')[:4]:
                    # Removes special characters from any entries
                    #                    text = td.text.encode('utf-8').replace('\xd1',"'").replace(
                    #                            '\xbf',"'").decode('ascii','ignore').strip()
                    text = td.text.strip()
                    rowList.append(' '.join(text.split()))
                # Convert state, zip to separate columns
                stateAndZip = tr.findAll('td')[4]
                rowList.append(stateAndZip.text.split(', ')[0])
                rowList.append(stateAndZip.text.split(', ')[1])
                # Convert map data to a google link
                mapURL = 'http://maps.google.com/maps?q=' + tr.find(
                    'a', href=True)['href'].split('daddr=')[1]
                rowList.append(mapURL)
                dropboxList.append(rowList)

            # Deduplicate the list whenever it exceeds a size greater than 500
            if len(dropboxList) > 500:
                dropboxList = dedup_list(dropboxList)

            # Print status update after every 25 zip codes have been scraped
            count += 1
            if count % 25 == 0:
                print('Completed ' +
                      str(round(((zips.index(code) / len(zips)) * 100), 2)) +
                      '% of list')

            # After scraping every 100 zip codes, export the list to a csv file
            if count % 100 == 0:
                print('Printing file: ' + code)
                # Convert storage container into pandas dataframe
                dropboxDF = pd.DataFrame(dropboxList,
                                         columns=[
                                             'Participant', 'CollectionSite',
                                             'Address', 'City', 'State', 'Zip',
                                             'MapURL'
                                         ])

                # Remove duplicate entries caused by querying nearby zip codes
                dropboxDF.drop_duplicates(inplace=True)

                # Export dataframe to CSV file in the working directory
                filename = (
                    'Data/October2018_NTBI/dropbox_addresses_October2018_' +
                    str(code) + '.csv')
                dropboxDF.to_csv(filename, index=False)
                dropboxList = []
                dropboxDF = pd.DataFrame()
            browser.back()

    # Output the final batch of locations
    dropboxDF = pd.DataFrame(dropboxList,
                             columns=[
                                 'Participant', 'CollectionSite', 'Address',
                                 'City', 'State', 'Zip', 'MapURL'
                             ])
    # Remove any duplicate entries caused by querying nearby zip codes
    dropboxDF.drop_duplicates(inplace=True)
    # Export dataframe to CSV file in the working directory
    filename = ('Data/October2018_NTBI/dropbox_addresses_October2018_' +
                str(code) + '.csv')
    dropboxDF.to_csv(filename, index=False)

    # Close the browser
    browser.close()
    return
Example #30
0
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.firefox.options import Options as FFOptions
from selenium.webdriver.chrome.options import Options as CHOptions

#assert "Python" in driver.title
#elem = driver.find_element_by_name("q")
#elem.clear()
#elem.send_keys("pycon")
#elem.send_keys(Keys.RETURN)
#assert "No results found." not in driver.page_source
ff_options = FFOptions()
ff_options.set_headless(True)

ch_options = CHOptions()
ch_options.set_headless(True)
#chrome = webdriver.Chrome(chrome_options = ch_options)
firefox = webdriver.Firefox(firefox_options=ff_options)
#phantom = webdriver.PhantomJS()
for i in range(100):
    #firefox.get("http://www.acfun.cn/")
    #print(firefox.title)
    #chrome.get("https://cn.bing.com/")
    firefox.get("https://www.baidu.com/")
    print(firefox.title, i)
#chrome.close()
firefox.close()
#phantom.close()
Example #31
0
def EventData(event_id):
    url = 'https://www.facebook.com/events/'+event_id
    try:
        fp = urllib.request.urlopen(url)
        mybytes = fp.read()
        mystr = mybytes.decode("utf8")
        fp.close()
    except:
        logs.print2("Couldn't load page")
        mystr = "null"
    #########gets event name
    try:
        text = mystr.split('data-testid="event-permalink-event-name">')[1]
        event_name = text.split('</h1')[0]
        if "&quot;" in event_name:
            event_name = event_name.replace("&quot;", '"')
        if "&#039;" in event_name:
            event_name = event_name.replace("&#039;", "'")
    except:
        logs.print2("Couldn't extract event name,god damn it facebook")
        event_name = "Couldn't extract event name"
    #########gets event date
    try:
        text = mystr.split('<span itemprop="startDate">')[1]
        text_left = text.split('</span>')[0]
        text_left = text_left+" "
        number_length = 4                                     
        pattern= r"\D(\d{%d})\D" % number_length      
        test = re.findall(pattern, text_left)
        if not test:
            now = datetime.datetime.now()
            event_date = text_left+" " + str(now.year)
        else:
            event_date = text_left 
    except:
        logs.print2("Couldn't extract event date,god damn it facebook")
        event_date = "Couldn't extract event date"
    #########gets event description
    options = Options()
    options.set_headless(headless=True)
    driver = webdriver.Firefox(firefox_options=options)
    try:       
        driver.get(url)
    except:
        logs.print2("Couldn't load page for event description")
    try:
        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'uiContextualLayerParent')))
        time.sleep(20)
    except TimeoutException:
        print('Page timed out after 10 secs.')
    try:
        soup = BeautifulSoup(driver.page_source, 'html.parser')
        driver.quit()
        text = soup.text.split('φίλους σας')[1]
        event_description = text.split('Δείτε τη συζήτηση')[0]
        event_description = event_description.split('Λεπτομέρειες')[1]
        event_description = event_description.split('Δείτε περισσότεραΠληροφορίες')[0]
    except:
        logs.print2("Couldn't extract event description,god damn it facebook")
        event_description = "Couldn't extract event description"
    return (event_description,event_date,event_name)
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.firefox.firefox_binary import FirefoxBinary

binary = FirefoxBinary('/home/nikolai/ff/firefox/firefox')

options = Options()
options.set_headless(headless=True)
driver = webdriver.Firefox(firefox_binary=binary,
    firefox_options=options, executable_path='../Drivers/geckodriver')
driver.get("http://google.com/")
print ("Headless Firefox Initialized")
driver.quit()
Example #33
0
 def _setup_firefox():
     opts = Options()
     opts.set_headless()
     assert opts.headless
     browser = Firefox(executable_path=GECKODRIVER_PATH, options=opts)
     return browser
Example #34
0
    def __init__(self, url):
        try:
            firefox_options = Options()
            firefox_options.set_headless()

            user_agent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7A341 Safari/528.16"
            profile = webdriver.FirefoxProfile()
            profile.set_preference("general.useragent.override", user_agent)

            executable_path = './drivers/geckodriver.exe'
            if sys.platform.startswith('linux'):
                executable_path = './drivers/geckodriver'

            self.browser = webdriver.Firefox(profile,
                                             options=firefox_options,
                                             executable_path=executable_path)
            self.browser.set_window_size(360, 640)
            self.browser.get(url)

            WebDriverWait(self.browser, 30).until(
                EC.presence_of_element_located((
                    By.XPATH,
                    r"//span[contains(text(), 'Help your friend slash the price!')]"
                ))).click()

            WebDriverWait(self.browser, 30).until(
                EC.presence_of_element_located(
                    (By.XPATH,
                     r"/html/body/div[1]/div/div[2]/div[1]/div/ul/li[1]/div"
                     ))).click()

            WebDriverWait(self.browser, 30).until(
                EC.presence_of_element_located((
                    By.XPATH,
                    r"/html/body/div[1]/div/div[2]/div[2]/div[1]/div/div/div/div[4]/div[1]/input"
                ))).send_keys(
                    str(random.randint(111111111111, 999999999999)) +
                    "@gmail.com")

            WebDriverWait(self.browser, 30).until(
                EC.presence_of_element_located((
                    By.XPATH,
                    r"/html/body/div[1]/div/div[2]/div[2]/div[1]/div/div/div/div[4]/div[2]/input"
                ))).send_keys("Ali" + str(random.randint(11111, 99999)) +
                              "Conta" + str(random.randint(11111, 99999)))

            WebDriverWait(self.browser, 30).until(
                EC.presence_of_element_located((
                    By.XPATH,
                    r"/html/body/div[1]/div/div[2]/div[2]/div[1]/div/div/div/div[4]/div[5]/a"
                ))).click()

            try:
                WebDriverWait(self.browser, 30).until(
                    EC.presence_of_element_located(
                        (By.XPATH, r"//a[contains(text(), 'CONFIRA!')]")))

                WebDriverWait(self.browser, 30).until(
                    EC.presence_of_element_located(
                        (By.XPATH, r"//span[@id='ms-back']"))).click()

                try:
                    WebDriverWait(self.browser, 30).until(
                        EC.presence_of_element_located((
                            By.XPATH,
                            r"//span[contains(text(), 'Ajude seu amigo a pechinchar')]"
                        ))).click()

                    try:
                        WebDriverWait(self.browser, 30).until(
                            EC.presence_of_element_located((
                                By.XPATH,
                                r"//div[contains(text(), 'Você acabou de cortar')]"
                            )))
                        print(
                            self.tipo_mensagem("sucesso",
                                               u"Ajudado com sucesso."))

                        time.sleep(2)
                        self.browser.close()
                        self.finalizar()

                    except NoSuchElementException:
                        print(
                            self.tipo_mensagem("erro",
                                               u"Não foi possivel Ajudar."))
                        self.browser.close()
                        self.finalizar()

                    except ElementClickInterceptedException:
                        print(
                            self.tipo_mensagem("erro",
                                               u"Não foi possivel Ajudar."))
                        self.browser.close()
                        self.finalizar()

                    except ElementNotInteractableException:
                        print(
                            self.tipo_mensagem("erro",
                                               u"Não foi possivel Ajudar."))
                        self.browser.close()
                        self.finalizar()

                except NoSuchElementException:
                    print(
                        self.tipo_mensagem("erro",
                                           u"Não foi possivel Ajudar."))
                    self.browser.close()
                    self.finalizar()

                except ElementClickInterceptedException:
                    print(
                        self.tipo_mensagem("erro",
                                           u"Não foi possivel Ajudar."))
                    self.browser.close()
                    self.finalizar()

                except ElementNotInteractableException:
                    print(
                        self.tipo_mensagem("erro",
                                           u"Não foi possivel Ajudar."))
                    self.browser.close()
                    self.finalizar()

            except NoSuchElementException:
                print(
                    self.tipo_mensagem(
                        "erro",
                        u"Não foi possivel encontrar os elementos na página."))
                self.browser.close()
                self.finalizar()

            except ElementClickInterceptedException:
                print(
                    self.tipo_mensagem(
                        "erro",
                        u"Não foi possivel encontrar os elementos na página."))
                self.browser.close()
                self.finalizar()

            except ElementNotInteractableException:
                print(
                    self.tipo_mensagem(
                        "erro",
                        u"Não foi possivel encontrar os elementos na página."))
                self.browser.close()
                self.finalizar()

        except NoSuchElementException:
            print(
                self.tipo_mensagem(
                    "erro",
                    u"Não foi possivel encontrar os elementos na página."))
            self.browser.close()
            self.finalizar()

        except ElementClickInterceptedException:
            print(self.tipo_mensagem("erro", u"Não foi possivel Ajudar."))
            self.browser.close()
            self.finalizar()

        except ElementNotInteractableException:
            print(
                self.tipo_mensagem(
                    "erro",
                    u"Não foi possivel encontrar os elementos na página."))
            self.browser.close()
            self.finalizar()

        except TimeoutException:
            print(
                self.tipo_mensagem(
                    "erro", u"Não foi possivel carregar a página de login."))
            self.browser.close()
            self.finalizar()
Example #35
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('yaml_settings')
    args = parser.parse_args()

    time = datetime.utcnow()
    with open(args.yaml_settings, 'r') as fh:
        yaml_settings = yaml.safe_load(fh)

    options = Options()
    options.set_headless(headless=True)
    driver = webdriver.Firefox(firefox_options=options)
    driver.implicitly_wait(150)
    try:
        driver.get("https://fugu.anon.edu/grafana/login/")
        driver.find_element_by_name("username").click()
        driver.find_element_by_name("username").clear()
        driver.find_element_by_name("username").send_keys("fugu")
        driver.find_element_by_id("inputPassword").click()
        driver.find_element_by_id("inputPassword").clear()
        driver.find_element_by_id("inputPassword").send_keys(GRAFANA_PWD)
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Help'])[1]/following::button[1]")
        driver.find_element_by_xpath(xpath).click()
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Help'])[1]/following::i[5]")
        driver.find_element_by_xpath(xpath).click()
        driver.find_element_by_link_text("Snapshot").click()
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Expire'])[1]/following::select[1]")
        driver.find_element_by_xpath(xpath).click()
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Expire'])[1]/following::select[1]")
        Select(driver.find_element_by_xpath(xpath)).select_by_visible_text(
            "1 Hour")
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Expire'])[1]/following::select[1]")
        driver.find_element_by_xpath(xpath).click()
        # begin code to set timeout
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Timeout (seconds)'])[1]/following::input[1]")
        driver.find_element_by_xpath(xpath).click()
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Timeout (seconds)'])[1]/following::input[1]")
        driver.find_element_by_xpath(xpath).clear()
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Timeout (seconds)'])[1]/following::input[1]")
        driver.find_element_by_xpath(xpath).send_keys("60")
        # end code to set timeout
        xpath = ("(.//*[normalize-space(text()) and normalize-space(.)"
                 "='Timeout (seconds)'])[1]/following::button[1]")
        driver.find_element_by_xpath(xpath).click()
        prefix = "https://fugu.anon.edu/grafana/dashboard/snapshot/"
        snapshot_url = driver.find_element_by_partial_link_text(prefix).text
        sys.stderr.write("Generated snapshot: {}\n".format(snapshot_url))
        driver.quit()
    except NoSuchElementException:
        driver.quit()
        sys.exit("Error generating snapshot")

    # Now, add this link to postgres, and delete old links from the table
    conn = None
    try:
        conn = connect_to_postgres(yaml_settings)
        cur = conn.cursor()

        add_snap_cmd = ("INSERT INTO fugu_grafanasnapshot "
                        "(url, created_on) VALUES (%s, %s)")
        cur.execute(add_snap_cmd, (snapshot_url, time))
        del_old_snap_cmd = "DELETE FROM fugu_grafanasnapshot WHERE (url) != (%s)"
        cur.execute(del_old_snap_cmd, (snapshot_url, ))

        conn.commit()
        cur.close()
    except:
        sys.stderr.write("Failed to post data to PostgreSQL\n")
    finally:
        if conn is not None:
            conn.close()
#asset "arizona" in driver.title


#==========================================



#=========================================================#
if __name__ == "__main__":

#========== Subprocess pckg (call) to get tor to work =========#
#=========== Adding ad nauseam extentesion =============#


    options = Options()
    options.set_headless(True)



geckodriver = '/Users/MyMac/Desktop/finalprojectesoc/geckodriver'

driver = webdriver.Firefox(executable_path=geckodriver, firefox_options=options)

wait = WebDriverWait(driver, timeout=10)

addon1 = '/Users/MyMac/Library/Application Support/Firefox/Profiles/i0nhni3z.default/extensions/[email protected]'
driver.install_addon(addon1, temporary=True)



Example #37
0
import random
import time
import asyncio
import threading
from concurrent import futures

from selenium.webdriver import Firefox
from selenium.webdriver.firefox.options import Options


options = Options()
options.set_headless()
# options.add_arguments("--disable-notifications")


debug = True

duration = 4


url = 'https://telugu.pratilipi.com/read?id=6755373518909383'

# proverbs
url = 'https://telugu.pratilipi.com/read?id=6755373518926758'


def read_url(url):
    driver = Firefox(options=options)
    driver.maximize_window()
    driver.get(url)
    time.sleep(4)
Example #38
0
    def __init__(self, client="firefox", username="******", proxy=None, command_executor=None, loadstyles=False,
                 profile=None, headless=False, autoconnect=True, logger=None, extra_params=None, chrome_options=None):
        """Initialises the webdriver"""

        self.logger = logger or self.logger
        extra_params = extra_params or {}

        if profile is not None:
            self._profile_path = profile
            self.logger.info("Checking for profile at %s" % self._profile_path)
            if not os.path.exists(self._profile_path):
                self.logger.critical("Could not find profile at %s" % profile)
                raise WhatsAPIException("Could not find profile at %s" % profile)
        else:
            self._profile_path = None

        self.client = client.lower()
        if self.client == "firefox":
            if self._profile_path is not None:
                self._profile = webdriver.FirefoxProfile(self._profile_path)
            else:
                self._profile = webdriver.FirefoxProfile()
            if not loadstyles:
                # Disable CSS
                self._profile.set_preference('permissions.default.stylesheet', 2)
                # Disable images
                self._profile.set_preference('permissions.default.image', 2)
                # Disable Flash
                self._profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
                                             'false')
            if proxy is not None:
                self.set_proxy(proxy)

            options = Options()

            if headless:
                options.set_headless()

            options.profile = self._profile

            capabilities = DesiredCapabilities.FIREFOX.copy()
            capabilities['webStorageEnabled'] = True

            self.logger.info("Starting webdriver")
            self.driver = webdriver.Firefox(capabilities=capabilities, options=options, **extra_params)

        elif self.client == "chrome":
            self._profile = webdriver.ChromeOptions()
            if self._profile_path is not None:
                self._profile.add_argument("user-data-dir=%s" % self._profile_path)
            if proxy is not None:
                self._profile.add_argument('--proxy-server=%s' % proxy)
            if headless:
                self._profile.add_argument('headless')
            if chrome_options is not None:
                for option in chrome_options:
                    self._profile.add_argument(option)
            self.logger.info("Starting webdriver")
            self.driver = webdriver.Chrome(chrome_options=self._profile, **extra_params)

        elif client == 'remote':
            if self._profile_path is not None:
                self._profile = webdriver.FirefoxProfile(self._profile_path)
            else:
                self._profile = webdriver.FirefoxProfile()
            capabilities = DesiredCapabilities.FIREFOX.copy()
            self.driver = webdriver.Remote(
                command_executor=command_executor,
                desired_capabilities=capabilities,
                **extra_params
            )

        else:
            self.logger.error("Invalid client: %s" % client)
        self.username = username
        self.wapi_functions = WapiJsWrapper(self.driver, self)

        self.driver.set_script_timeout(500)
        self.driver.implicitly_wait(10)

        if autoconnect:
            self.connect()