Exemple #1
0
def book(s, list_booking):
    to_book = None
    for booking in list_booking:
        if booking['hour'] == '20':
            to_book = booking
            break

    if to_book != None:
        payload = {'cle': to_book['payload']}
        rep = s.post(
            'https://teleservices.paris.fr/srtm/reservationCreneauReserver.action',
            data=payload)

        captcha = s.get('https://teleservices.paris.fr/srtm/ImageCaptcha'
                        ).text.encode('ISO-8859-1')
        solver = CaptchaSolver('browser')
        payload['jcaptcha_reponse'] = solver.solve_captcha(captcha)
        payload['valider'] = 'ENREGISTRER'
        rep = s.post(
            'https://teleservices.paris.fr/srtm/ReservationCreneauValidationForm.action',
            data=payload)

        if rep.ok:
            print 'Book done in %s the %s at %sh' % (
                to_book['short'], to_book['date'], to_book['hour'])
        else:
            print 'Fail booking'
    else:
        print 'No book found'
 def setUp(self):
     self.solver = CaptchaSolver('browser')
     self.wb_patcher = patch('webbrowser.open')
     self.mock_wb_open = self.wb_patcher.start()
     self.raw_input_patcher = patch('captcha_solver.captcha_backend'
                                    '.browser.input')
     self.mock_raw_input = self.raw_input_patcher.start()
Exemple #3
0
def create_group(chat_title):
    chat_title = "MEOW" + str(chat_title)
    try:
        thischat = api.messages.createChat(user_ids=chat_users_list,
                                           title=chat_title,
                                           v=APIVersion)
        api.messages.removeChatUser(chat_id=thischat,
                                    user_id=334479550,
                                    v=APIVersion)

    except Exception as e:
        captcha_sid = vk.exceptions.VkAPIError.captcha_sid.__get__(e)
        captcha_url = vk.exceptions.VkAPIError.captcha_img.__get__(e)
        if (captcha_sid == None) and (captcha_url == None):
            time.sleep(3)
            api.messages.createChat(user_ids=chat_users_list,
                                    title=chat_title,
                                    v=APIVersion)
        requests_image(captcha_url)
        solver = CaptchaSolver("antigate", api_key=antigate_token)
        raw_data = open("captchaGROUP.jpg", "rb").read()
        captcha_ready = solver.solve_captcha(raw_data)
        print(captcha_ready)
        api.messages.createChat(
            user_ids=chat_users_list,
            title=chat_title,
            v=APIVersion,
            captcha_sid=captcha_sid,
            captcha_key=captcha_ready,
        )
Exemple #4
0
def add_audio(access_token, audio_id, owner_id):
    global headers
    response = requests.get(
        "https://api.vk.com/method/audio.add?access_token=" + access_token +
        "&audio_id=" + str(audio_id) + "&owner_id=" + str(owner_id) +
        "&v=5.71",
        headers=headers,
        verify=False,
    ).json()
    try:
        print(response["response"])
    except:
        print("****Капча на add_audio****\n" +
              response["error"]["captcha_img"])
        captcha_sid = response["error"]["captcha_sid"]
        requests_image(response["error"]["captcha_img"])
        solver = CaptchaSolver("antigate", api_key=antigate_token)
        raw_data = open("captcha.jpg", "rb").read()
        captcha_ready = solver.solve_captcha(raw_data)
        print(captcha_ready)
        print("Пробуем..")

        check = requests.get(
            "https://api.vk.com/method/audio.add?access_token=" +
            access_token + "&audio_id=" + str(audio_id) + "&owner_id=" +
            str(owner_id) + "&v=5.71&captcha_sid=" + captcha_sid +
            "&captcha_key=" + captcha_ready,
            headers=headers,
            verify=False,
        ).json()

        if check["response"] != None:
            print("Все успешно!")
Exemple #5
0
 def solve_captcha(self):
     if not self.captcha_img_el:
         return
     captcha_solver = CaptchaSolver('rucaptcha', api_key=RUCAPTCHA_API_KEY)
     img_path = os.path.join(os.getcwd(), 'captcha.png')
     self.captcha_img_el.screenshot(img_path)
     key = captcha_solver.solve_captcha(open(img_path, mode='rb').read())
     self.captcha_input_el.send_keys(key)
Exemple #6
0
def captcha_solve(url, key):
    if key is not None:
        try:
            solver = CaptchaSolver('antigate', api_key=key)
            raw_data = requests.get(url, stream=True).raw.read()
            key = solver.solve_captcha(raw_data)
            return key
        except Exception as e:
            print("Exception: ", e)
    return None
Exemple #7
0
    def _resolve_captcha(self, image_url):
        image_bytes = requests.get(image_url).content
        image = Image.open(BytesIO(image_bytes))
        w, h = image.size
        image = image.crop((0, 0, w, h - 12))
        image.save('tmp/captcha.jpg')

        image_bytes = BytesIO()
        image.save(image_bytes, format='JPEG')
        image_bytes = image_bytes.getvalue()

        solver = CaptchaSolver('rucaptcha', api_key=RutrackerParser.RUCAPTCHA_KEY)
        result = solver.solve_captcha(image_bytes)
        return result
def break_captcha(driver):
    #get captcha image
    try:
        img = driver.find_element_by_class_name("captcha__image")
        src = img.get_attribute('src')
        urllib.request.urlretrieve(src, "captcha.png")

        solver = CaptchaSolver('rucaptcha',
                               api_key='bef7004b9dcbbcba502cd826f2bafa49')
        raw_data = open('captcha.png', 'rb').read()
        captcha_text = solver.solve_captcha(raw_data)
    except captcha_solver.error.CaptchaServiceError:
        driver.find_element_by_class_name("captcha__image").click()
        break_captcha(driver)
    return captcha_text
Exemple #9
0
    def getRuCaptchaSolver(self, filename):
        """

        :param filename: - Имя файла с фотографией капчи
        :return: - Вернет саму отгадку капчи
        """

        while True:
            try:
                solver = CaptchaSolver('rucaptcha', api_key=self.rucaptcha_key)
                raw_data = open(filename, 'rb').read()

                return solver.solve_captcha(raw_data)

            except:
                pass
Exemple #10
0
 def __solve_captcha(captcha_url: str):
     """
     downloads captcha image and send to 2captcha to solve
     :param captcha_url: Captcha image url
     :return: string with captcha solution
     """
     img_name = f'{uuid4()}.jpg'
     if OutlookAccountCreator.__download_image(captcha_url, img_name):
         print('Solving Captcha...')
         solver = CaptchaSolver('2captcha', api_key=API_2_CAPTCHA)
         raw_data = open(img_name, 'rb').read()
         solution = solver.solve_captcha(raw_data)
         os.remove(img_name)
         print(f"Captcha solved (solution: {solution})...")
         return solution
     print('Failed to download captcha image...')
Exemple #11
0
    def captcha_handler(captcha):
        from Settings import RUCAPTCHA_KEY

        url = captcha.get_url()

        image_url = requests.get(url)
        img = image_url.content

        file = open('tmp.jpg', "wb")
        file.write(img)
        file.close()

        solver = CaptchaSolver('rucaptcha', api_key=RUCAPTCHA_KEY)
        raw_data = open('tmp.jpg', 'rb').read()

        return captcha.try_again(solver.solve_captcha(raw_data))
Exemple #12
0
    def __init__(self, settings, logger=None):
        if logger:
            self.logger = logger
        else:
            self.logger = logging.Logger("vk_controller")

        self.vk_users = []
        self.vk_groups = []
        self.scope = settings.SCOPE
        self.group = False
        self.app_id = settings.APP_ID
        self.current_user = 0
        self.current_token = 0

        self.target_client = None

        self.hold = 0

        self.proxies = settings.PROXIES
        if not self.proxies:
            self.proxies = []

        self.users_data = settings.USERS
        if not self.users_data:
            self.users_data = []

        self.solver = None
        if settings.CAPTCHA_KEY and settings.CAPTCHA_SERVER:
            self.solver = CaptchaSolver(settings.CAPTCHA_SERVER, api_key=settings.CAPTCHA_KEY)

        loop = asyncio.get_event_loop()
        if not loop.is_running():
            loop.run_until_complete(self.init_vk())
Exemple #13
0
class GuiTestCase(TestCase):

    def setUp(self):
        self.solver = CaptchaSolver('gui')
        self.cw_patcher = patch('captcha_solver.captcha_backend'
                                '.gui.CaptchaWindow')
        self.mock_cw = self.cw_patcher.start()

    def tearDown(self):
        self.cw_patcher.stop()

    def test_captcha_decoded(self):

        class MockCW(object):
            def __init__(self, path, solution):
                self.solution = solution
                self.solution.append('decoded_captcha')

            def main(self):
                pass

        self.mock_cw.side_effect = MockCW

        self.assertEqual(self.solver.solve_captcha(b'image_data'),
                         'decoded_captcha')
Exemple #14
0
 def create_solver(self, **kwargs):
     config = {
         'service_url': self.server.get_url(),
         'api_key': 'does not matter',
     }
     config.update(kwargs)
     return CaptchaSolver('antigate', **config)
    def resolveNormalCaptcha(self, image_path, retry=5):
        if not self._api_key:
            logging.info("No 2captcha API key")
            return None

        while retry > 0:
            try:
                raw_data = open(image_path, 'rb').read()
                logging.info("Resolving captcha...")
                solver = CaptchaSolver('2captcha', api_key=self._api_key)
                captcha_code = solver.solve_captcha(raw_data)
                logging.info('Captcha code is:{}'.format(captcha_code))

                return captcha_code
            except print(0):
                pass
        return None
Exemple #16
0
 def __init__(self, email: str) -> None:
     self.failed_email_user_id = 0
     self.bot_email = email
     self.queue_from_bot = email
     self.applicant = Applicant()
     self.loop = asyncio.get_event_loop()
     self.current_appeal: Optional[dict] = None
     self.stop_timer = Timer(self.stop_appeal_sending, self.loop)
     self.captcha_solver = CaptchaSolver()
     self.user_captcha_text: Optional[str] = None
Exemple #17
0
    def solve_captcha(self, response):
        if os.environ.get('ANTICAPTCHA_API_KEY'):
            solver = CaptchaSolver('antigate',
                                   api_key=os.environ['ANTICAPTCHA_API_KEY'])
        else:
            solver = CaptchaSolver('browser')

        # Can fetch this a few time and get different randomly-generated captchas to help make a better guess.
        # See: https://ereg.elections.ca/Telerik.Web.UI.WebResource.axd?type=rca&isc=true&guid=2d918a7f-09cb-4e0e-92e2-125d4ddb156a
        captcha_path = response.css(
            '#ctl00_ContentPlaceHolder1_RadCaptcha1_CaptchaImage::attr(src)'
        ).extract_first()
        captcha_url = 'https://ereg.elections.ca/{}'.format(captcha_path)
        jpg_data = urllib.request.urlopen(captcha_url).read()

        self.crawler.engine.pause()
        captcha = solver.solve_captcha(jpg_data)
        self.crawler.engine.unpause()

        formdata = {
            '__EVENTTARGET':
            '',
            '__EVENTARGUMENT':
            '',
            '__VIEWSTATE':
            response.css('#__VIEWSTATE::attr(value)').extract_first(),
            '__EVENTVALIDATION':
            response.css('#__EVENTVALIDATION::attr(value)').extract_first(),
            'ctl00$ContentPlaceHolder1$txtCaptcha':
            captcha,
        }
        yield FormRequest.from_response(
            response,
            formdata=formdata,
            formcss='#form1',
            clickdata={
                'name': 'ctl00$ContentPlaceHolder1$NavButton$BtnNextDelay'
            },
            callback=self.parse_vote_eligibility,
        )
Exemple #18
0
    def _bake_captcha(self, comment_block):
        import requests
        from requests.exceptions import InvalidURL
        from captcha_solver import CaptchaSolver

        url_image = comment_block.element("img#captcha").src
        try:
            get_img = requests.get(url_image, stream=True)
        except InvalidURL:
            capthca_url_without_auth = url_image.replace('t:123456%@',
                                                         '') + '.jpeg'
            get_img = requests.get(capthca_url_without_auth,
                                   stream=True,
                                   auth=('t', '123456%'))

        with open('captcha_rating.jpeg', 'wb') as fd:
            for chunk in get_img.iter_content(chunk_size=128):
                fd.write(chunk)
        solver = CaptchaSolver('antigate',
                               api_key='3d756e5391dd1e1423739217e6579c1a')
        raw_data = open('captcha_rating.jpeg', 'rb').read()

        return solver.solve_captcha(raw_data)
Exemple #19
0
def handle_captcha(res):
    if 'validateCaptcha' not in res.text:
        return res
    print '='*78
    with open('captcha.html', 'w') as file:
        file.write(res.content)
    soup = BeautifulSoup(res.text, 'html.parser')
    elems = soup.select('form img')
    fields = {
        elem.attrs['name']: elem.attrs['value']
        for elem in soup.select('form input[type="hidden"]')
    }
    print 'Image: ' + elems[0].attrs['src']
    img = session.get(elems[0].attrs['src'])
    with open('captcha.jpg', 'wb') as file:
        file.write(img.content)
    solver = CaptchaSolver('browser')
    fields['field-keywords'] = solver.solve_captcha(img.content).upper()
    res = session.get(
        'https://www.amazon.de/errors/validateCaptcha',
        params=fields)
    print '='*78
    return handle_captcha(res)
Exemple #20
0
    def __init__(self, settings, logger=None):
        if logger:
            self.logger = logger
        else:
            self.logger = logging.Logger("vk_controller")

        self.settings = settings

        self.vk_users = []
        self.vk_groups = []
        self.scope = settings.SCOPE
        self.group = False
        self.app_id = settings.APP_ID
        self.current_user = 0
        self.current_token = 0

        self.target_client = None

        self.hold = 0

        self.proxies = settings.PROXIES
        if not self.proxies:
            self.proxies = []

        if not isinstance(settings.USERS, (list, tuple)) or not settings.USERS:
            raise ValueError(
                "You have wrong `USERS` variable in settings. Please, check again."
            )

        for PACK in settings.USERS:
            if not isinstance(PACK, (list, tuple)) or len(PACK) < 2 or len(
                    PACK) > 3 or PACK[0] not in ("group", "user"):
                raise ValueError(
                    "You have wrong entity in `USERS` in settings: " +
                    str(PACK))

        self.users_data = settings.USERS
        if not self.users_data:
            self.users_data = []

        self.solver = None
        if settings.CAPTCHA_KEY and settings.CAPTCHA_SERVER:
            self.solver = CaptchaSolver(settings.CAPTCHA_SERVER,
                                        api_key=settings.CAPTCHA_KEY)

        loop = asyncio.get_event_loop()
        if not loop.is_running():
            loop.run_until_complete(self.init_vk())
Exemple #21
0
class BrowserTestCase(TestCase):
    def setUp(self):
        self.solver = CaptchaSolver('browser')
        self.wb_patcher = patch('webbrowser.open')
        self.mock_wb_open = self.wb_patcher.start()
        self.raw_input_patcher = patch('captcha_solver.backend.browser.input')
        self.mock_raw_input = self.raw_input_patcher.start()

    def tearDown(self):
        self.wb_patcher.stop()
        self.raw_input_patcher.stop()

    def test_captcha_decoded(self):
        self.mock_wb_open.return_value = None
        self.mock_raw_input.return_value = 'decoded_captcha'

        self.assertEqual(self.solver.solve_captcha(b'image_data'),
                         'decoded_captcha')
Exemple #22
0
class BrowserTestCase(TestCase):

    def setUp(self):
        self.solver = CaptchaSolver('browser')
        self.wb_patcher = patch('webbrowser.open')
        self.mock_wb_open = self.wb_patcher.start()
        self.raw_input_patcher = patch('captcha_solver.captcha_backend'
                                       '.browser.input')
        self.mock_raw_input = self.raw_input_patcher.start()

    def tearDown(self):
        self.wb_patcher.stop()
        self.raw_input_patcher.stop()

    def test_captcha_decoded(self):
        self.mock_wb_open.return_value = None
        self.mock_raw_input.return_value = 'decoded_captcha'

        self.assertEqual(self.solver.solve_captcha(b'image_data'),
                         'decoded_captcha')
Exemple #23
0
class GuiTestCase(TestCase):
    def setUp(self):
        self.solver = CaptchaSolver('gui')
        self.cw_patcher = patch('captcha_solver.backend.gui.CaptchaWindow')
        self.mock_cw = self.cw_patcher.start()

    def tearDown(self):
        self.cw_patcher.stop()

    def test_captcha_decoded(self):
        class MockCW(object):
            def __init__(self, path, solution):
                self.solution = solution
                self.solution.append('decoded_captcha')

            def main(self):
                pass

        self.mock_cw.side_effect = MockCW

        self.assertEqual(self.solver.solve_captcha(b'image_data'),
                         'decoded_captcha')
Exemple #24
0
 def __init__(self,
              url,
              f_name,
              l_name,
              username,
              psw,
              phone,
              month,
              day,
              year,
              psw_confirm=None,
              email=None,
              gender=None,
              _zip=None,
              button=None,
              country=None,
              captcha_img_alt=None,
              captcha_input_label=None):
     self.url = url
     self.f_name_id = f_name
     self.l_name_id = l_name
     self.username_id = username
     self.psw_id = psw
     self.phone_id = phone
     self.month_id = month
     self.day_id = day
     self.year_id = year
     self.psw_confirm_id = psw_confirm
     self.gender_id = gender
     self.zip_id = _zip
     self.button_id = button
     self.email_id = email
     self.country_id = country
     self.captcha_img_alt = captcha_img_alt
     if captcha_img_alt:
         self.captcha_solver = CaptchaSolver('rucaptcha',
                                             api_key=RUCAPTCHA_API_KEY)
     self.captcha_input_label = captcha_input_label
Exemple #25
0
driver.find_element_by_id('ap_customer_name').send_keys(name)
driver.find_element_by_id('ap_email').send_keys(email)
driver.find_element_by_id('ap_password').send_keys(password)
driver.find_element_by_id('ap_password_check').send_keys(password)
driver.find_element_by_xpath("//*[@id='continue']").click()

try: # to bypass the captcha code
    from captcha_solver import CaptchaSolver
    from io import BytesIO
    from PIL import Image
    element = driver.find_element_by_xpath("//img[@id='auth-captcha-image']")
    png = driver.get_screenshot_as_png()
    im = Image.open(BytesIO(png))
    im = im.crop((1000,1190,1380,1330))
    im.save('captcha.png')
    solver = CaptchaSolver('antigate', api_key='18ebda48664c28ce6ebc86baa3701579')
    captcha = open('captcha.png', 'rb').read()
    captchaCode = solver.solve_captcha(captcha) # solves the captcha puzzle
    driver.find_element_by_xpath("//*[@id='auth-captcha-guess']").send_keys(captchaCode)
    driver.find_element_by_id('ap_password').send_keys(password)
    driver.find_element_by_id('ap_password_check').send_keys(password)
    driver.find_element_by_xpath("//*[@id='continue']").click()
except NoSuchElementException: # unless there isn't a captcha code
    pass

# pass the next page
driver.switch_to.window(driver.window_handles[-1])
driver.find_element_by_xpath("//*[@id='payments_widget_add_credit_card_number']").send_keys(creditCard)
driver.find_element_by_xpath("//select[@name='expirationMonth']/option[@value='11']").click()
driver.find_element_by_xpath("//select[@name='expirationYear']/option[@value='2021']").click()
driver.find_element_by_xpath("//*[@id='payments_widget_full_name']").send_keys(name)
Exemple #26
0
from captcha_solver import CaptchaSolver
solver=CaptchaSolver('browser')
with open('/images/sbi.png','rb') as inp:
	raw_data=inp.read()
print(solver.solve_captcha(raw_data))
  
Exemple #27
0
 def setUp(self):
     self.solver = CaptchaSolver('gui')
     self.cw_patcher = patch('captcha_solver.captcha_backend'
                             '.gui.CaptchaWindow')
     self.mock_cw = self.cw_patcher.start()
class AntigateUrllibTestCase(BaseSolverTestCase):
    def setup_solver(self):
        self.solver = CaptchaSolver('antigate',
                                    network_backend='urllib',
                                    service_url=self.server.get_url(),
                                    api_key='does not matter')

    def test_post_data(self):
        data = b'foo'
        res = self.solver.captcha_backend.get_submit_captcha_request_data(data)
        body = res['post_data']['body']

        self.assertTrue(isinstance(body, string_types))

    def test_antigate_decoded(self):
        def handler():
            yield b'OK|captcha_id'
            yield b'OK|decoded_captcha'

        self.server.response['data'] = handler()
        self.assertEqual(self.solver.solve_captcha(b'image_data'),
                         'decoded_captcha')

    def test_antigate_no_slot_available(self):
        self.server.response_once['data'] = b'ERROR_NO_SLOT_AVAILABLE'
        self.assertRaises(SolutionTimeoutError, self.solver.solve_captcha,
                          b'image_data', **NO_DELAY)

    def test_antigate_zero_balance(self):
        self.server.response_once['data'] = b'ERROR_ZERO_BALANCE'
        self.assertRaises(BalanceTooLow, self.solver.solve_captcha,
                          b'image_data')

    def test_antigate_unknown_error(self):
        self.server.response_once['data'] = b'UNKNOWN_ERROR'
        self.assertRaises(CaptchaServiceError, self.solver.solve_captcha,
                          b'image_data')

    def test_antigate_unknown_code(self):
        self.server.response_once['code'] = 404
        self.assertRaises(CaptchaServiceError, self.solver.solve_captcha,
                          b'image_data')

    def test_solution_timeout_error(self):
        def handler():
            yield b'OK|captcha_id'
            yield b'CAPCHA_NOT_READY'

        self.server.response['data'] = handler()
        self.assertRaises(SolutionTimeoutError, self.solver.solve_captcha,
                          b'image_data', **NO_DELAY)

    def test_solution_unknown_error(self):
        def handler():
            yield b'OK|captcha_id'
            yield b'UNKNOWN_ERROR'

        self.server.response['data'] = handler()
        self.assertRaises(CaptchaServiceError, self.solver.solve_captcha,
                          b'image_data', **NO_DELAY)

    def test_solution_unknown_code(self):
        def handler():
            yield b'OK|captcha_id'

        self.server.response['data'] = handler()
        self.assertRaises(CaptchaServiceError, self.solver.solve_captcha,
                          b'image_data', **NO_DELAY)
#br.set_debug_redirects(True)
#br.set_debug_responses(True)

# Open first page
response = br.open(home_url)

# Find CAPTCHA URL and download the image file
html1 = response.read()
page = BeautifulSoup(html1, "lxml")
end_img_url = page.findAll("img")[0].attrs["src"][2:]
captcha_url = base_img_url + end_img_url
br.retrieve(captcha_url, captcha_file)

# Manually solve the captcha
print "Please enter below the number shown in the viewer window:"
solver = CaptchaSolver("browser")
with open(captcha_file, "rb") as f:
    raw_data = f.read()
captcha_solution = solver.solve_captcha(raw_data)

# Submit form to search for funds
br.select_form(nr=0)
br.set_all_readonly(False)
br.form["txtCNPJNome"] = cnpj
br.form["ddlTpFdo"] = 0
br.form["numRandom"] = captcha_solution

sleep(1)
response = br.submit()

# Select fund on search results list
class Copor_TrueSearch(QThread):
    solver = CaptchaSolver()

    dirName = 'corporationwiki_truepeople'
    logcallback = pyqtSignal(object, object)
    mutex = QMutex()
    progress_bar = 0
    step_plus = 0

    try:
        os.mkdir(dirName)
        print("Directory ", dirName, " Created ")
    except FileExistsError:
        print("Directory ", dirName, " already exists ")

    def __init__(self, keyword):
        QThread.__init__(self)
        self.keyword = keyword
        # self.logcallback = logcallback
        self.paused = False
        self.default_url = "https://www.truepeoplesearch.com/results?name={0}&citystatezip={1}"
        self.base_url = "https://www.truepeoplesearch.com/results?name={0}&citystatezip={1}&page={2}"

    def _check_task_paused(self):
        while self.paused:
            print('Sleeping')
            self.sleep(1)

    def _intialize(self):
        self.logcallback.emit("#Now making csv file...........................", 2)
        # Qtcore

        open(self.dirName + "/" + "{}.csv".format(self.keyword), "wb").close()
        header = ["Company Name", "Name", "Role", "Address", "Age", "Filling Type", "Status", "State", "Foreign State",
                  "County", "State ID", "Date Filed", "DOS Process", "Phone1", "phone2", "phone3", "phone4", "phone5",
                  "phone6", "phone7", "phone8", "phone9", "phone10", "email1", "email2", "email3", "email4", "email5",
                  "email6", "email7", "email8", "email9", "email10"]

        with open(self.dirName + "/" + "{}.csv".format(self.keyword), "a", newline="") as f:
            csv_writer = csv.DictWriter(f, fieldnames=header, lineterminator='\n')
            csv_writer.writeheader()

        self.logcallback.emit("#Open chrome browser open now.....", 4)
        self.path = "driver\\chromedriver.exe"
        self.driver = Chrome(executable_path=self.path)

        self.logcallback.emit("### Open Chrome Browser2 now.............", 6)
        self.driver1 = Chrome(executable_path=self.path)

        self.logcallback.emit("### Open Chrome Browser3 now.............", 8)
        self.driver2 = Chrome(executable_path=self.path)

        self.logcallback.emit("### Open Chrome Browser4 now.............", 10)
        self.driver3 = Chrome(executable_path=self.path)

        self.driver.get("https://www.corporationwiki.com/")
        self.driver.maximize_window()
        self.driver1.maximize_window()
        self.driver2.maximize_window()
        self.driver3.maximize_window()

    def parse_page(self):
        item_urls = []
        companyNames = []

        self._intialize()

        self._check_task_paused()
        time.sleep(5)
        self.logcallback.emit("### First Page Scraping Start.................", 10)

        driver = self.driver
        driver1 = self.driver1
        driver2 = self.driver2
        driver3 = self.driver3

        searchKeyword = driver.find_element_by_id("keywords")
        searchKeyword.send_keys(self.keyword)
        searchKeyword.send_keys(Keys.ENTER)

        self._check_task_paused()
        self.logcallback.emit("#Input key word... and search....", 10)
        self.progress_bar = 10
        time.sleep(5)

        companyName_xpaths = driver.find_elements_by_xpath("//div[@class='list-group-item']//a[@class='ellipsis']")
        all_counts = len(companyName_xpaths)
        self.step_plus = (100 - self.progress_bar) / 6
        self.logcallback.emit("Search Results---------------> : {}".format(all_counts), self.progress_bar)

        for companyName_xpath in companyName_xpaths:
            # Checking task is paused or not
            self._check_task_paused()
            companyName = companyName_xpath.text
            item_url = companyName_xpath.get_attribute("href")

            companyNames.append(companyName)
            item_urls.append(item_url)

            print("Company Name-----------------> : ", companyName)
            print("Item URL---------------------> : ", item_url)

        print(companyNames, item_urls)

        for companyName, item_url in zip(companyNames, item_urls):
            self._check_task_paused()

            name = ""
            role = ""
            address = ""
            age = ""
            filling_type = ""
            status = ""
            state = ""
            foreign_state = ""
            county = ""
            state_id = ""
            date_filed = ""
            dos_process = ""

            self.data = {
                "company_name": "",
                "name": "",
                "role": "",
                "address": "",
                "age": "",
                "filling_type": "",
                "status": "",
                "state": "",
                "foreign_state": "",
                "county": "",
                "state_id": "",
                "date_filed": "",
                "dos_process": ""
            }

            driver.get(item_url)
            self.progress_bar = self.progress_bar + self.step_plus
            self.logcallback.emit("Redirect into {}".format(item_url), self.progress_bar)
            time.sleep(4)

            name = driver.find_element_by_xpath("//a[@class='ellipsis']").text
            role = driver.find_element_by_xpath("//div[contains(@class, 'role-label')]").text

            print("------------------------------------------------------------------------------")

            for i in range(0, 9):
                # Checking task is paused or not
                self._check_task_paused()
                if str(i) in name:
                    name = name.replace(str(i), "")

            try:
                streetAddress = driver.find_element_by_xpath("//span[@itemprop='streetAddress']").text
                locality = driver.find_element_by_xpath("//span[@itemprop='addressLocality']").text
                region = driver.find_element_by_xpath("//span[@itemprop='addressRegion']").text
                postalCode = driver.find_element_by_xpath("//span[@itemprop='postalCode']").text

                address = streetAddress + " " + locality + " " + region + " " + postalCode

                background_url = driver.find_element_by_xpath(
                    "//table[@class='list-table']//tbody//tr[1]/td[1]/div/a").get_attribute("href")
                print("BackgroundUrl-------------------> : ", background_url)
                # Checking task is paused or not
                self._check_task_paused()
                driver.get(background_url)

                # Checking task is paused or not
                self._check_task_paused()
                time.sleep(4)

                age = driver.find_element_by_class_name("display-age").text
            except:

                label_xpaths = driver.find_elements_by_xpath(
                    "(//table[contains(@class, 'table') and contains(@class, 'table-striped') and contains(@class, 'pad-bottom')])[1]/tbody//tr//th")

                info_xpaths = driver.find_elements_by_xpath(
                    "(//table[contains(@class, 'table') and contains(@class, 'table-striped') and contains(@class, 'pad-bottom')])[1]/tbody//tr//td")

                for label_xpath, info_xpath in zip(label_xpaths, info_xpaths):
                    # Checking task is paused or not
                    self._check_task_paused()
                    labelTxt = label_xpath.text
                    infoTxt = info_xpath.text

                    if "Filing Type" in labelTxt:
                        filling_type = infoTxt
                    elif "Status" in labelTxt:
                        status = infoTxt
                    elif "State" in labelTxt and "ID" not in labelTxt and "Foreign" not in labelTxt:
                        state = infoTxt
                    elif "Foreign State" in labelTxt:
                        foreign_state = infoTxt
                    elif "County" in labelTxt:
                        county = infoTxt
                    elif "State ID" in labelTxt:
                        state_id = infoTxt
                    elif "Date Filed" in labelTxt:
                        date_filed = infoTxt
                    elif "DOS Process" in labelTxt:
                        dos_process = infoTxt

                address = county + " " + state + " " + state_id

                background_url = driver.find_element_by_xpath(
                    "//table[@class='list-table']//tbody//tr[1]/td[1]/div/a").get_attribute("href")
                print("BackgroundUrl-------------------> : ", background_url)
                self.progress_bar = self.progress_bar + self.step_plus
                self.logcallback.emit("Background checking...", self.progress_bar)
                # Checking task is paused or not
                self._check_task_paused()
                driver.get(background_url)
                self.progress_bar = self.progress_bar + self.step_plus
                self.logcallback.emit("Redirect into : {}".format(background_url), self.progress_bar)
                # Checking task is paused or not
                self._check_task_paused()
                time.sleep(4)

                age = driver.find_element_by_class_name("display-age").text

            self.progress_bar = self.progress_bar + self.step_plus

            self.data["company_name"] = companyName
            self.data["name"] = name
            self.data["role"] = role
            self.data["address"] = address
            self.data["age"] = age
            self.data["filling_type"] = filling_type
            self.data["status"] = status
            self.data["state"] = state
            self.data["foreign_state"] = foreign_state
            self.data["county"] = county
            self.data["state_id"] = state_id
            self.data["date_filed"] = date_filed
            self.data["dos_process"] = dos_process

            self.turepeopleSearch(driver1, driver2, driver3, self.data)

    def turepeopleSearch(self, driver1, driver2, driver3, data):
        url = self.default_url.format(data["name"], data["address"])
        driver1.get(url)
        self._check_task_paused()

        try:
            self.logcallback.emit("### Recaptcha Detecting >>>................", 24)
            recaptcha = driver1.find_element_by_class_name("g-recaptcha")
            recaptchaFlag = True
            self.logcallback.emit("### Recaptcha Detection True...............", 26)
        except:
            recaptchaFlag = False
            self.logcallback.emit("### Recaptcha Detection False..............", 26)

        if recaptchaFlag == True:
            self.logcallback.emit("### Recaptcha Solving Now..................", 26)
            self.solver.solve_captcha_for_url(driver1, driver1.current_url)
            driver1.find_element_by_xpath('//button').click()
            self.logcallback.emit("### Recaptcha Solved.......................", 26)

        try:
            itemsInfo = driver1.find_element_by_xpath("//html/body/div[2]/div/div[2]/div[3]/div[1]").text
            totals = int((itemsInfo.split(" "))[0])
            page_counts = math.ceil(totals / 11)
            self.logcallback.emit("### Total Item Accounts....................", 28)
            next_flag = False
            self.logcallback.emit("### Total {} PAGE....................".format(page_counts), 20)

            for page in range(1, page_counts + 1):
                self._check_task_paused()
                if page != 1:
                    driver1.get(self.base_url.format(data["name"], data["address"], page))
                    time.sleep(2)
                try:
                    self.logcallback.emit("### Recaptcha Detecting >>>................", 31)
                    recaptcha = driver1.find_element_by_class_name("g-recaptcha")
                    recaptchaFlag = True
                    self.logcallback.emit("### Recaptcha Detection True...............", 32)
                except:
                    recaptchaFlag = False
                    self.logcallback.emit("### Recaptcha Detection False..............", 32)

                if recaptchaFlag == True:
                    self.logcallback.emit("### Recaptcha Solving Now..................", 34)
                    self.solver.solve_captcha_for_url(driver1, driver1.current_url)
                    self.driver.find_element_by_xpath('//button').click()
                    self.logcallback.emit("### Recaptcha Solved.......................", 36)

                ownerXpaths = driver1.find_elements_by_xpath(
                    "//div[contains(@class, 'card-summary')]//div[@class='h4']")

                viewButtons = driver1.find_elements_by_xpath(
                    "//div[contains(@class, 'card-summary')]//div[contains(@class, 'align-self-center')]/a")

                for ownerXpath, viewButton in zip(ownerXpaths, viewButtons):
                    self._check_task_paused()
                    ownerName = ownerXpath.text

                    flag = self.destinction(ownerName.lower(), self.data["name"].lower())

                    if flag == 2:
                        self.logcallback.emit("### First Mode.......................", 30)
                        second_url = viewButton.get_attribute('href')
                        driver2.get(second_url)
                        self._check_task_paused()
                        self.parse_owner(driver2.page_source, driver2)
                        next_flag = True
                        break

                    elif flag == 1:
                        self.logcallback.emit("### Second Mode.......................", 30)
                        second_url = viewButton.get_attribute('href')
                        driver3.get(second_url)
                        self._check_task_paused()
                        self.parse_ownerfind(driver3.page_source, driver3, driver2, self.data["name"])
                        next_flag = True
                        break

                if next_flag == True:
                    break

        except:
            print("continue")

    def parse_owner(self, htmlstring, driver2):
        self._check_task_paused()
        self.logcallback.emit("### GET INFOS.......................", 35)
        try:
            self.logcallback.emit("### Recaptcha Detecting >>>................", 36)
            recaptcha = driver2.find_element_by_class_name("g-recaptcha")
            recaptchaFlag = True
            self.logcallback.emit("### Recaptcha Detection True...............", 38)
        except:
            recaptchaFlag = False
            self.logcallback.emit("### Recaptcha Detection False..............", 38)

        if recaptchaFlag == True:
            self.logcallback.emit("### Recaptcha Solving Now..................", 40)
            self.solver.solve_captcha_for_url(driver2, driver2.current_url)
            driver2.find_element_by_xpath('//button').click()
            self.logcallback.emit("### Recaptcha Solved.......................", 44)

        phone_data = {
            "phone1": "",
            "phone2": "",
            "phone3": "",
            "phone4": "",
            "phone5": "",
            "phone6": "",
            "phone7": "",
            "phone8": "",
            "phone9": "",
            "phone10": ""
        }

        email_data = {
            "email1": "",
            "email2": "",
            "email3": "",
            "email4": "",
            "email5": "",
            "email6": "",
            "email7": "",
            "email8": "",
            "email9": "",
            "email10": "",
        }

        with open(self.dirName + "/" + "{}.csv".format(self.keyword), "a", newline="", encoding='utf-8') as f:
            writer = csv.writer(f)
            self.logcallback.emit("### Open  {}.csv File...............".format(self.keyword), 45)

            phones = re.findall(r'[(][\d]{3}[)][ ]?[\d]{3}-[\d]{4}', driver2.page_source)
            emails = re.findall(r'[\w\.-]+@[\w\.-]+', driver2.page_source)

            for phone in range(1, len(phones) + 1):
                phone_data["phone{}".format(phone)] = phones[phone - 1]

            for email in range(1, len(emails) + 1):
                if 'truepeople' not in emails[email - 1]:
                    email_data["email{}".format(email)] = emails[email - 1]

            writer.writerow([self.data["company_name"], self.data["name"], self.data["role"], self.data["address"],
                             self.data["age"], self.data["filling_type"], self.data["status"], self.data["state"],
                             self.data["foreign_state"], self.data["county"], self.data["state_id"],
                             self.data["date_filed"], self.data["dos_process"], phone_data["phone1"],
                             phone_data["phone2"], phone_data["phone3"], phone_data["phone4"], phone_data["phone5"],
                             phone_data["phone6"], phone_data["phone7"], phone_data["phone8"], phone_data["phone9"],
                             phone_data["phone10"], email_data["email1"], email_data["email2"], email_data["email3"],
                             email_data["email4"], email_data["email5"], email_data["email6"], email_data["email7"],
                             email_data["email8"], email_data["email9"], email_data["email10"]])

        self.logcallback.emit("*****************************End*******************************", 100)

    def parse_ownerfind(self, htmlstring, driver3, driver2, original_ownerName):
        try:
            recaptcha = driver3.find_element_by_class_name("g-recaptcha")
            recaptchaFlag = True
        except:
            recaptchaFlag = False

        if recaptchaFlag == True:
            print('Stage2')
            self.solver.solve_captcha_for_url(driver3, driver3.current_url)
            driver3.find_element_by_xpath('//button').click()
            print('Stage2 done')

        infos = driver3.find_elements_by_xpath("//a[contains(@class, 'link-to-more') and contains(@class, 'olnk')]")

        for info in infos:
            relName = info.text
            rel_array = (relName.lower()).split(" ")
            ori_arry = (original_ownerName.lower()).split(" ")

            common = list(set(rel_array).intersection(ori_arry))
            if len(common) == 2:
                owner_url = info.get_attribute("href")
                print("relName----------------------->", relName, owner_url)
                driver3.get(owner_url)
                time.sleep(2)
                try:
                    itemsInfo = driver3.find_element_by_xpath("//html/body/div[2]/div/div[2]/div[3]/div[1]").text
                    totals = int((itemsInfo.split(" "))[0])
                    page_counts = math.ceil(totals / 11)
                    print("Total Items Accounts  2----------------------> : ", page_counts)

                    for page in range(1, page_counts + 1):
                        if page != 1:
                            self.driver1.get((owner_url + "&page={}").format(page))
                            time.sleep(2)

                        ownerXpaths = driver3.find_elements_by_xpath(
                            "//div[contains(@class, 'card-summary')]//div[@class='h4']")

                        viewButtons = driver3.find_elements_by_xpath(
                            "//div[contains(@class, 'card-summary')]//div[contains(@class, 'align-self-center')]/a")

                        for ownerXpath, viewButton in zip(ownerXpaths, viewButtons):
                            ownerName = ownerXpath.text
                            # print(ownerName)
                            flag = self.destinction(ownerName.lower(), original_ownerName.lower())

                            if flag == 2:
                                second_url = viewButton.get_attribute('href')
                                driver2.get(second_url)
                                self.parse_owner(driver2.page_source, driver2)
                                break
                except:
                    driver2.get(owner_url)
                    self.parse_owner(driver2.page_source, driver2)

                break

    @staticmethod
    def destinction(ownerName, original_Name):

        print("OwnerName-----------> : ", ownerName)
        print("Original_Name-------> : ", original_Name)
        owner_array = ownerName.split(" ")
        original_array = original_Name.split(" ")

        common = list(set(owner_array).intersection(original_array))

        if len(common) >= 2:
            return 2
        elif len(common) == 1 and len(common[0]) != 1:
            return 1
        else:
            return False

    def run(self):
        try:
            self.parse_page()

            self.driver.close()
            self.driver.quit()
            self.driver1.close()
            self.driver1.quit()
            self.driver2.close()
            self.driver2.quit()
            self.driver3.close()
            self.driver3.quit()

        except Exception as e:
            pass
    print('Your userid', userid, 'is not valid')
    print('Choose another one by login in', entry_url)
    sys.exit()

# extract link to captcha
imgs = soup.find_all("img")
gif_id = [img['src'] for img in imgs if 'Security' in str(img)][0]
gif = 'https://ready.arl.noaa.gov' + gif_id

# download captcha, save
result = requests.get(gif, stream=True)
with open('captcha.png', 'wb') as out_file:
    shutil.copyfileobj(result.raw, out_file)

# Solve captcha
solver = CaptchaSolver('browser')
raw_data = open('captcha.png', 'rb').read()
code = solver.solve_captcha(raw_data)

# Get proc number
inputs = soup.find_all('input')
proc = [inp['value'] for inp in inputs if 'proc' in str(inp)][0]
profile = metfile
payload2 = make_payload2(metfile,
                         proc,
                         code,
                         userid=userid,
                         year=year,
                         month=month,
                         day=day,
                         hour=hour,
Exemple #32
0
 def setup_solver(self):
     self.solver = CaptchaSolver('antigate',
                                 network_backend='urllib',
                                 service_url=self.server.get_url(),
                                 api_key='does not matter')
Exemple #33
0
from time import sleep

from selenium import webdriver
from selenium.webdriver.support.ui import Select
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.keys import Keys

from captcha_solver import CaptchaSolver

solver = CaptchaSolver('2captcha', api_key='金鑰')

options = Options()
options.binary_location = "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
webdriver_path = 'C:\\chromedriver_win32\\chromedriver.exe'

#解決使用 AJAX 動態載入資料的 Single Page Application 應用問題
url = 'https://lvr.land.moi.gov.tw/login.action'

driver = webdriver.Chrome(executable_path=webdriver_path, options=options)
driver.get(url)

#1.關閉說明浮動選單
sleep(2)
dialog_close = driver.find_element_by_class_name(
    'ui-dialog-titlebar-close').click()

#2.選不動產買買
sleep(2)
land_sale = driver.find_element_by_xpath(
    '//div[@class="main_menu"]/ul[@class="sale"]/li/a[@id="land"]').click()
 def setup_solver(self):
     self.solver = CaptchaSolver('antigate',
                                 network_backend='grab',
                                 service_url=self.server.get_url(),
                                 api_key='does not matter')
Exemple #35
0
def decode():
    solver = CaptchaSolver('browser')
    with open('test.jpg', 'rb') as inp:
        raw_data = inp.read()
    print(solver.solve_captcha(raw_data))
Exemple #36
0
		name_now = api.messages.getChat(chat_id=conf_id,v=APIVersion)
		check = name_now['title']

        #Если надо, то меняем название
		if check != chat_titles[str(i+1)]:
			try:
				api.messages.editChat(chat_id=conf_id,title=chat_titles[str(i+1)],v=APIVersion)
			except Exception as e:

				captcha_sid=vk.exceptions.VkAPIError.captcha_sid.__get__(e)
				captcha_url = vk.exceptions.VkAPIError.captcha_img.__get__(e)
				if (captcha_sid == None) and (captcha_url == None):
					time.sleep(3)
					api.messages.editChat(chat_id=conf_id,title=chat_titles[str(i+1)],v=APIVersion)
				requests_image(captcha_url)
				solver = CaptchaSolver('antigate', api_key=antigate_token)
				raw_data = open('captcha.jpg', 'rb').read()
				captcha_ready = solver.solve_captcha(raw_data)
				api.messages.editChat(chat_id=conf_id,title=chat_titles[str(i+1)],v=APIVersion,captcha_sid=captcha_sid,captcha_key=captcha_ready)
	checker = False

	for i in range(len(response['updates'])):
		if checker != True:
			try:

				message_longpoll = response['updates'][i][5]
				chat_longpoll = response['updates'][i][3]-2000000000
				checker = True

			except:
				pass
Exemple #37
0
import logging

logger = logging.getLogger(__name__)

import json
import time
import urllib.parse

import requests
from captcha_solver import CaptchaSolver
from django.conf import settings

captcha_solver = CaptchaSolver("rucaptcha", api_key=settings.KOCHERGA_RUCAPTCHA_KEY)

API_VERSION = "5.81"


def api_key():
    return settings.KOCHERGA_VK_API_KEY


def group_api_key():
    return settings.KOCHERGA_VK_GROUP_API_KEY


def check_response(r):
    if "error" in r:
        raise Exception(r["error"])
    if "execute_errors" in r:
        raise Exception(r["execute_errors"])
    if "response" not in r:
Exemple #38
0
def solve_captcha():
    solver =CaptchaSolver('browser')
    imgdata = requests.get("http://xk.fudan.edu.cn/xk/captcha/image.action?d=" + time.time(), cookies=coo,headers=loginheaders)
    print(imgdata.headers)
    ans=solver.solve_captcha(imgdata.content)
    return ans