diff --git a/Makefile b/Makefile index b0464f9..39ad4e8 100644 --- a/Makefile +++ b/Makefile @@ -5,14 +5,15 @@ remove: pip uninstall python3-anticaptcha -y test: - pip install pytest pytest-cov pytest-asyncio requests_mock - pytest tests --cov=python3_anticaptcha/ -v + pip install pytest coverage pytest-asyncio requests_mock + coverage run -m pytest tests -v --disable-warnings + coverage report -m python3_anticaptcha/*.py refactor: pip install black isort black python3_anticaptcha/ isort -rc python3_anticaptcha/ -upload: - pip install twine +release: + pip install wheel twine python setup.py upload diff --git a/README.md b/README.md index 5024153..4386c7e 100644 --- a/README.md +++ b/README.md @@ -220,6 +220,5 @@ Some examples you can test with our [web-site](https://pythoncaptcha.tech/). 1. Clon repo; 2. ```bash export anticaptcha_key=SERVICE_KEY - pip install pytest pytest-asyncio requests_mock - pytest tests + make test ``` diff --git a/anticaptcha_examples/anticaptcah_image_to_text_example.py b/anticaptcha_examples/anticaptcah_image_to_text_example.py index 524b622..118118a 100644 --- a/anticaptcha_examples/anticaptcah_image_to_text_example.py +++ b/anticaptcha_examples/anticaptcah_image_to_text_example.py @@ -25,9 +25,7 @@ save_format = 'const' . result = ImageToTextTask.ImageToTextTask( anticaptcha_key=ANTICAPTCHA_KEY, save_format="const" -).captcha_handler( - captcha_link="https://pythoncaptcha.tech/static/image/common_image_example/800070.png" -) +).captcha_handler(captcha_link="https://pythoncaptcha.tech/static/image/common_image_example/800070.png") print(result) # Пример который показывает работу антикапчи при решении капчи-изображением и сохранением её в качестве ВРЕМЕННОГО файла @@ -45,14 +43,12 @@ Base64 files An example of working with decoding in base64 captcha-file after download. On-the-fly-encoding """ base_64_link = base64.b64encode( - requests.get( - "https://pythoncaptcha.tech/static/image/common_image_example/862963.png" - ).content + requests.get("https://pythoncaptcha.tech/static/image/common_image_example/862963.png").content ).decode("utf-8") -user_answer_base64 = ImageToTextTask.ImageToTextTask( - anticaptcha_key=ANTICAPTCHA_KEY -).captcha_handler(captcha_base64=base_64_link) +user_answer_base64 = ImageToTextTask.ImageToTextTask(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( + captcha_base64=base_64_link +) """ Пример работы со скачанными файлами изображений капчи. @@ -80,9 +76,9 @@ print(result) # captcha_file = r'D:\Python\933588.png' # captcha_file = 'D:\/Python\/933588.png' try: - user_answer_local = ImageToTextTask.ImageToTextTask( - anticaptcha_key=ANTICAPTCHA_KEY - ).captcha_handler(captcha_file=captcha_file) + user_answer_local = ImageToTextTask.ImageToTextTask(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( + captcha_file=captcha_file + ) if user_answer_local["errorId"] == 0: # решение капчи print(user_answer_local["solution"]["text"]) @@ -112,15 +108,15 @@ async def run(): print(resolve) - resolve = await ImageToTextTask.aioImageToTextTask( - anticaptcha_key=ANTICAPTCHA_KEY - ).captcha_handler(captcha_file=captcha_file) + resolve = await ImageToTextTask.aioImageToTextTask(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( + captcha_file=captcha_file + ) print(resolve) - resolve = await ImageToTextTask.aioImageToTextTask( - anticaptcha_key=ANTICAPTCHA_KEY - ).captcha_handler(captcha_base64=base_64_link) + resolve = await ImageToTextTask.aioImageToTextTask(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( + captcha_base64=base_64_link + ) print(resolve) @@ -158,9 +154,7 @@ if answer == "OK": result = ImageToTextTask.ImageToTextTask( anticaptcha_key=ANTICAPTCHA_KEY, callbackUrl=f"https://pythoncaptcha.tech:8001/anticaptcha/image_to_text/{QUEUE_KEY}", - ).captcha_handler( - captcha_link="https://pythoncaptcha.tech/static/image/common_image_example/800070.png" - ) + ).captcha_handler(captcha_link="https://pythoncaptcha.tech/static/image/common_image_example/800070.png") print(result) # получение результата из кеша diff --git a/anticaptcha_examples/anticaptcha_control_example.py b/anticaptcha_examples/anticaptcha_control_example.py index 8ea5dd3..e1a2679 100644 --- a/anticaptcha_examples/anticaptcha_control_example.py +++ b/anticaptcha_examples/anticaptcha_control_example.py @@ -7,25 +7,23 @@ ANTICAPTCHA_KEY = "" # Пример метода, отправляющего жалобу на неправильно решённую капчу-изображение. # В качестве параметра, принимает ключ антикапчи и ID неправильно решённой капчи + тип капчи # Возвращает логические True(жалоба прошла)/False(ошибка при жалобе) -result = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=ANTICAPTCHA_KEY -).complaint_on_result(reported_id=-5, captcha_type="image") +result = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=ANTICAPTCHA_KEY).complaint_on_result( + reported_id=-5, captcha_type="image" +) print(result) # Пример метода, отправляющего жалобу на неправильно решённую ReCaptcha. # В качестве параметра, принимает ключ антикапчи и ID неправильно решённой ReCaptcha + тип капчи # Возвращает логические True(жалоба прошла)/False(ошибка при жалобе) -result = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=ANTICAPTCHA_KEY -).complaint_on_result(reported_id=-5, captcha_type="recaptcha") +result = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=ANTICAPTCHA_KEY).complaint_on_result( + reported_id=-5, captcha_type="recaptcha" +) print(result) # Пример метода, принимающего ключ аккаунта и возвращающего актуальный баланс result = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=ANTICAPTCHA_KEY).get_balance() print(result) # Пример метода, выдающий информацию о загрузке очереди, в зависимости от ID очереди # В данном случае queue_id = 1, то есть получаем информацию по загрузке очереди ImageToText (язык английский) -result = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=ANTICAPTCHA_KEY).get_queue_status( - queue_id=1 -) +result = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=ANTICAPTCHA_KEY).get_queue_status(queue_id=1) print(result) # Асинхронный метод работы diff --git a/anticaptcha_examples/anticaptcha_fun_example.py b/anticaptcha_examples/anticaptcha_fun_example.py index c607de5..ffb7482 100644 --- a/anticaptcha_examples/anticaptcha_fun_example.py +++ b/anticaptcha_examples/anticaptcha_fun_example.py @@ -20,9 +20,9 @@ result = FunCaptchaTask.FunCaptchaTask( print(result) # Пример работы антикапчи с фанкапчёй и с БЕЗ использования прокси при этом -result = FunCaptchaTaskProxyless.FunCaptchaTaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY -).captcha_handler(websiteURL=WEB_URL, websitePublicKey=SITE_KEY) +result = FunCaptchaTaskProxyless.FunCaptchaTaskProxyless(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( + websiteURL=WEB_URL, websitePublicKey=SITE_KEY +) print(result) diff --git a/anticaptcha_examples/anticaptcha_hcaptcha_example.py b/anticaptcha_examples/anticaptcha_hcaptcha_example.py index 4edc41e..4b4288c 100644 --- a/anticaptcha_examples/anticaptcha_hcaptcha_example.py +++ b/anticaptcha_examples/anticaptcha_hcaptcha_example.py @@ -21,9 +21,9 @@ result = HCaptchaTask.HCaptchaTask( print(result) # Пример работы антикапчи с фанкапчёй и с БЕЗ использования прокси при этом -result = HCaptchaTaskProxyless.HCaptchaTaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY -).captcha_handler(websiteURL=WEB_URL, websiteKey=SITE_KEY) +result = HCaptchaTaskProxyless.HCaptchaTaskProxyless(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( + websiteURL=WEB_URL, websiteKey=SITE_KEY +) print(result) diff --git a/anticaptcha_examples/anticaptcha_nocaptcha_example.py b/anticaptcha_examples/anticaptcha_nocaptcha_example.py index 0c6de9c..5e57f84 100644 --- a/anticaptcha_examples/anticaptcha_nocaptcha_example.py +++ b/anticaptcha_examples/anticaptcha_nocaptcha_example.py @@ -1,7 +1,7 @@ import asyncio import requests -from python3_anticaptcha import NoCaptchaTaskProxyless, NoCaptchaTask, CallbackClient +from python3_anticaptcha import NoCaptchaTaskProxyless, NoCaptchaTask ANTICAPTCHA_KEY = "ae23fffcfaa29b170e3843e3a486ef19" @@ -10,9 +10,7 @@ ANTICAPTCHA_KEY = "ae23fffcfaa29b170e3843e3a486ef19" Синхронный пример без прокси Sync example without proxy """ -result = NoCaptchaTaskProxyless.NoCaptchaTaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY -).captcha_handler( +result = NoCaptchaTaskProxyless.NoCaptchaTaskProxyless(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( websiteURL="https://www.google.com/recaptcha/api2/demo", websiteKey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-", ) @@ -51,6 +49,8 @@ print(result) Асинхронный пример без прокси Async example without proxy """ + + async def run(): try: result = await NoCaptchaTaskProxyless.aioNoCaptchaTaskProxyless( @@ -68,48 +68,3 @@ if __name__ == "__main__": loop = asyncio.get_event_loop() loop.run_until_complete(run()) loop.close() - -""" -Callback example -""" -QUEUE_KEY = "wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ_anticaptcha_queue" - -""" -Перед тем как начать пользоваться сервисом нужно создать для своей задачи отдельную очередь -Очередь можно создать один раз и пользоваться постоянно - -Для создания очереди нужно передать два параметра: -1. key - название очереди, чем оно сложнее тем лучше -2. vhost - название виртуального хоста(в данном случаи - `anticaptcha_vhost`) -""" - -answer = requests.post( - "https://pythoncaptcha.tech:8001/register_key", - json={"key": QUEUE_KEY, "vhost": "anticaptcha_vhost"}, -) -# если очередь успешно создана: -if answer == "OK": - # создаём задание с callbackURL параметром - result = NoCaptchaTask.NoCaptchaTask( - anticaptcha_key=ANTICAPTCHA_KEY, - proxyType="http", - proxyAddress="8.8.8.8", - proxyPort=8080, - proxyLogin="proxyLoginHere", - proxyPassword="proxyPasswordHere", - callbackUrl=f"https://pythoncaptcha.tech:8001/anticaptcha/nocaptcha/{QUEUE_KEY}", - ).captcha_handler( - websiteURL="https://www.google.com/recaptcha/api2/demo", - websiteKey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-", - ) - - print(result) - - # получение результата из кеша - print(CallbackClient.CallbackClient(task_id=result["taskId"]).captcha_handler()) - # получение результата из RabbitMQ очереди - print( - CallbackClient.CallbackClient( - task_id=result["taskId"], queue_name=QUEUE_KEY, call_type="queue" - ).captcha_handler() - ) diff --git a/anticaptcha_examples/anticaptcha_recaptcha_v3_example.py b/anticaptcha_examples/anticaptcha_recaptcha_v3_example.py index 6ace5ff..c6b0d53 100644 --- a/anticaptcha_examples/anticaptcha_recaptcha_v3_example.py +++ b/anticaptcha_examples/anticaptcha_recaptcha_v3_example.py @@ -12,9 +12,7 @@ WARNING: # Пример показывает работу антикапчи с ReCaptcha v3. # Это метод для работы без прокси -result = ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY -).captcha_handler( +result = ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( websiteURL="https://some_page_link", websiteKey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-", minScore=0.3, @@ -23,9 +21,7 @@ result = ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless( print(result) # contextmanager -with ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY -) as recaptcha: +with ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless(anticaptcha_key=ANTICAPTCHA_KEY) as recaptcha: response = recaptcha.captcha_handler( websiteURL="https://some_page_link", websiteKey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-", diff --git a/anticaptcha_examples/anticaptcha_square_net_task.py b/anticaptcha_examples/anticaptcha_square_net_task.py index 33ad87d..5968dbe 100644 --- a/anticaptcha_examples/anticaptcha_square_net_task.py +++ b/anticaptcha_examples/anticaptcha_square_net_task.py @@ -26,9 +26,7 @@ print(result) # Асинхронный метод работы / Asyncio exaple async def run(): - result = await SquareNetTextTask.aioSquareNetTextTask( - anticaptcha_key=ANTICAPTCHA_KEY - ).captcha_handler( + result = await SquareNetTextTask.aioSquareNetTextTask(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler( objectName="captcha numbers", rowsCount=2, columnsCount=3, diff --git a/anticaptcha_examples/callback_examples.py b/anticaptcha_examples/callback_examples.py deleted file mode 100644 index eb83156..0000000 --- a/anticaptcha_examples/callback_examples.py +++ /dev/null @@ -1,94 +0,0 @@ -import asyncio - -import requests - -from python3_anticaptcha import NoCaptchaTaskProxyless, CallbackClient - -ANTICAPTCHA_KEY = "ae23fffcfaa29b170e3843e3a486ef19" -QUEUE_KEY = "wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ_anticaptcha_queue" - -""" -Пример показывает работу с модулем CallbackClient на основе работы с NoCaptchaTaskProxyless -(точно так же это работает со всеми остальными доступными методами решения капчи) -предназначенным для получения ответа не капчу высланного на callback сервер. -------------------------------------------------------------- -Все решения которые получает сервер записываются в: -1. RabbitMQ очередь, в которой сообщение после прочтения пользователем удаляется -2. Кеш(memcached) в котором сообщение хранится 1 час -""" - -""" -Перед тем как начать пользоваться сервисом нужно создать для своей задачи отдельную очередь -Очередь можно создать один раз и пользоваться постоянно - -Для создания очереди нужно передать два параметра: -1. key - название очереди, чем оно сложнее тем лучше -2. vhost - название виртуального хоста(в данном случаи - `anticaptcha_vhost`) -""" - -answer = requests.post( - "https://pythoncaptcha.tech:8001/register_key", - json={"key": QUEUE_KEY, "vhost": "anticaptcha_vhost"}, -) -# если очередь успешно создана: -if answer == "OK": - - # Пример показывает работу антикапчи с "невидимой" рекапчёй от гугла, точно так же работает обычная рекапча от гугла. - # Это метод для работы без прокси - result = NoCaptchaTaskProxyless.NoCaptchaTaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY, - callbackUrl=f"https://pythoncaptcha.tech:8001/anticaptcha/nocaptcha/{QUEUE_KEY}", - ).captcha_handler( - websiteURL="https://www.google.com/recaptcha/api2/demo", - websiteKey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-", - ) - print(result) - - # получение результата из кеша - print(CallbackClient.CallbackClient(task_id=result["taskId"]).captcha_handler()) - # получение результата из RabbitMQ очереди с переопределением стандартных параметров - print( - CallbackClient.CallbackClient( - task_id=result["taskId"], queue_name=QUEUE_KEY, call_type="queue" - ).captcha_handler( - requests_timeout=0.5, - auth_params={ - "host": "https://pythoncaptcha.tech/", - "port": "8001", - "rtmq_username": "hardworker_1", - "rtmq_password": "password", - "rtmq_host": "https://pythoncaptcha.tech/", - "rtmq_port": "5672", - "rtmq_vhost": "anticaptcha_vhost", - }, - ) - ) - - # Асинхронный пример - async def run(): - try: - result = await NoCaptchaTaskProxyless.aioNoCaptchaTaskProxyless( - anticaptcha_key=ANTICAPTCHA_KEY, - callbackUrl=f"https://pythoncaptcha.tech:8001/anticaptcha/nocaptcha/{QUEUE_KEY}", - ).captcha_handler( - websiteURL="https://www.google.com/recaptcha/api2/demo", - websiteKey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-", - ) - print(result) - - # получение результата из кеша - print(CallbackClient.CallbackClient(task_id=result["taskId"]).captcha_handler()) - # получение результата из RabbitMQ очереди, со стандартными параметрами - print( - CallbackClient.CallbackClient( - task_id=result["taskId"], queue_name=QUEUE_KEY, call_type="queue" - ).captcha_handler() - ) - - except Exception as err: - print(err) - - if __name__ == "__main__": - loop = asyncio.get_event_loop() - loop.run_until_complete(run()) - loop.close() diff --git a/pyproject.toml b/pyproject.toml index 3d01dc4..07103cd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [tool.black] -line-length = 99 +line-length = 110 target-version = ['py36'] exclude = ''' /( diff --git a/python3_anticaptcha/AntiCaptchaControl.py b/python3_anticaptcha/AntiCaptchaControl.py index 481ac15..31d7353 100644 --- a/python3_anticaptcha/AntiCaptchaControl.py +++ b/python3_anticaptcha/AntiCaptchaControl.py @@ -21,7 +21,7 @@ mods = ("errors", "views", "downloads", "users", "money") # available complaint captcha types complaint_types = ("image", "recaptcha") # availalbe queue ID's -queue_ids = (1, 2, 5, 6, 7, 10, 11, 12, 13, 18, 19, 20) +queue_ids = (1, 2, 5, 6, 7, 10, 11, 12, 13, 18, 19, 20, 21, 22) queues_names = ( "English ImageToText", @@ -57,15 +57,11 @@ class AntiCaptchaControl: Получение баланса аккаунта :return: Возвращает актуальный баланс """ - answer = requests.post( - get_balance_url, json={"clientKey": self.ANTICAPTCHA_KEY}, verify=False - ) + answer = requests.post(get_balance_url, json={"clientKey": self.ANTICAPTCHA_KEY}, verify=False) return answer.json() - def send_funds( - self, accountLogin: str = None, accountEmail: str = None, amount: float = None - ) -> dict: + def send_funds(self, accountLogin: str = None, accountEmail: str = None, amount: float = None) -> dict: """ Отправить средства другому пользователю В вашем аккаунте должна быть включена опция отправки средств через API. @@ -99,8 +95,7 @@ class AntiCaptchaControl: """ if queue and queue not in queues_names: raise ValueError( - f"\nWrong `queue` parameter. Valid params: {queues_names}." - f"\n\tYour param - `{queue}`" + f"\nWrong `queue` parameter. Valid params: {queues_names}." f"\n\tYour param - `{queue}`" ) payload = { "clientKey": self.ANTICAPTCHA_KEY, @@ -119,9 +114,7 @@ class AntiCaptchaControl: :return: Возвращает актуальный баланс """ if mode not in mods: - raise ValueError( - f"\nWrong `mode` parameter. Valid params: {mods}." f"\n\tYour param - `{mode}`" - ) + raise ValueError(f"\nWrong `mode` parameter. Valid params: {mods}." f"\n\tYour param - `{mode}`") payload = {"clientKey": self.ANTICAPTCHA_KEY, "softId": softId, "mode": mode} answer = requests.post(get_app_stats_url, json=payload, verify=False) @@ -188,8 +181,7 @@ class AntiCaptchaControl: if queue_id not in queue_ids: raise ValueError( - f"\nWrong `mode` parameter. Valid params: {queue_ids}." - f"\n\tYour param - `{queue_id}`" + f"\nWrong `mode` parameter. Valid params: {queue_ids}." f"\n\tYour param - `{queue_id}`" ) payload = {"queueId": queue_id} @@ -220,9 +212,7 @@ class aioAntiCaptchaControl: :return: Возвращает актуальный баланс """ async with aiohttp.ClientSession() as session: - async with session.post( - get_balance_url, json={"clientKey": self.ANTICAPTCHA_KEY} - ) as resp: + async with session.post(get_balance_url, json={"clientKey": self.ANTICAPTCHA_KEY}) as resp: if await resp.text(): return await resp.json() else: @@ -268,8 +258,7 @@ class aioAntiCaptchaControl: """ if queue and queue not in queues_names: raise ValueError( - f"\nWrong `queue` parameter. Valid params: {queues_names}." - f"\n\tYour param - `{queue}`" + f"\nWrong `queue` parameter. Valid params: {queues_names}." f"\n\tYour param - `{queue}`" ) payload = { "clientKey": self.ANTICAPTCHA_KEY, @@ -292,9 +281,7 @@ class aioAntiCaptchaControl: :return: Возвращает актуальный баланс """ if mode not in mods: - raise ValueError( - f"\nWrong `mode` parameter. Valid params: {mods}." f"\n\tYour param - `{mode}`" - ) + raise ValueError(f"\nWrong `mode` parameter. Valid params: {mods}." f"\n\tYour param - `{mode}`") payload = {"clientKey": self.ANTICAPTCHA_KEY, "softId": softId, "mode": mode} async with aiohttp.ClientSession() as session: async with session.post(get_app_stats_url, json=payload) as resp: @@ -363,8 +350,7 @@ class aioAntiCaptchaControl: """ if queue_id not in queue_ids: raise ValueError( - f"\nWrong `mode` parameter. Valid params: {queue_ids}." - f"\n\tYour param - `{queue_id}`" + f"\nWrong `mode` parameter. Valid params: {queue_ids}." f"\n\tYour param - `{queue_id}`" ) payload = {"queueId": queue_id} diff --git a/python3_anticaptcha/CallbackClient.py b/python3_anticaptcha/CallbackClient.py deleted file mode 100644 index 9ac0927..0000000 --- a/python3_anticaptcha/CallbackClient.py +++ /dev/null @@ -1,188 +0,0 @@ -import json -import time - -import pika -import requests - -from python3_anticaptcha import ( - HOST, - PORT, - RTMQ_HOST, - RTMQ_PORT, - RTMQ_VHOST, - RTMQ_PASSWORD, - RTMQ_USERNAME, -) - - -class CallbackClient: - """ - Класс отвечает за получение информации о решении капчи с call-back сервера - """ - - def __init__(self, task_id: int, queue_name: str = None, call_type: str = "cache"): - """ - :param task_id: ID полученное при создании задания в сервисе AntiCaptcha - :param queue_name: Название очереди выбранное и переданное последним параметров в URL для `pingback`. - Если передан параметр `call_type=queue` то поле это обязательное. - :param call_type: Ресурс к которому будут отправлятся запросы: `cache` или `queue` - """ - # заполняем данные IP/PORT - self.host = HOST - self.port = PORT - - # ID задания - self.task_id = int(task_id) - # тип запросов к серверу - self.call_type = call_type - if self.call_type in ("cache", "queue"): - if self.call_type == "queue": - if queue_name: - self.queue_name = queue_name - - # заполянем данные для подключения к очереди - self.rtmq_username = RTMQ_USERNAME - self.rtmq_password = RTMQ_PASSWORD - self.rtmq_host = RTMQ_HOST - self.rtmq_port = RTMQ_PORT - self.rtmq_vhost = RTMQ_VHOST - else: - raise ValueError( - "\nВыбран тип получения решения `call_type=queue`, но не передан параметр названия очереди - `queue_name`. " - f"\n\tПередайте параметр `queue_name` или измените `call_type=queue` на `call_type=cache`" - "\nYou select `call_type=queue` but don`t set `queue_name` param." - f"\n\tSet `queue_name` param or change `call_type=queue` to `call_type=cache`" - ) - - else: - raise ValueError( - "\nПередан неверный формат для запросов к callback серверу. " - f"\n\tВозможные варинты: `cache` или `queue`. Вы передали - `{self.call_type}`" - "\nWrong `call_type` parameter. Valid params: `cache` or `queue`." - f"\n\tYour param - `{self.call_type}`" - ) - - def __handle_queue_message(self, requests_timeout: int): - """ - Метод отвечает за подключение к RabbitMQ очереди и ожидания сообщения с нужным `task_id` - :param requests_timeout: Время между запросами к серверу. - """ - # кол-во попыток на получение результата - attempts = 20 - - # подключаемся к RabbitMQ и устанавливаем осединение + канал - parameters = pika.URLParameters( - f"amqp://{self.rtmq_username}:{self.rtmq_password}@{self.rtmq_host}:{self.rtmq_port}/{self.rtmq_vhost}" - ) - connection = pika.BlockingConnection(parameters=parameters) - channel = connection.channel() - - while attempts > 0: - # получение сообщения из очереди - method_frame, _, body = channel.basic_get(self.queue_name) - if body: - # декодируем сообщение из bytes в JSON - json_body = json.loads(body.decode()) - - # если ID задания сообщения из очереди совпадает с ID требуемого задания - возвращаем его. - # если ID не совпадают - ожидаем дальше - if int(json_body.get("taskId")) == self.task_id: - channel.basic_ack(method_frame.delivery_tag) - connection.close() - return json_body - # ставим небольшую задержку что бы не спамить сервер rabbitmq - time.sleep(requests_timeout) - # уменьшаем счётчик попыток - attempts -= 1 - - return False - - def __handle_cache_message(self, requests_timeout: int): - """ - Метод отвечает за подключение к серверу, передачу `task_id` и получение резульатата решения капчи из кеша - :param requests_timeout: Время между запросами к серверу. - """ - # кол-во попыток на получение результата - attempts = 20 - - # создание сессии - session = requests.Session() - session.verify = False - - while attempts > 0: - with session.get( - f"http://{self.host}:{self.port}/anticaptcha/cache/{self.task_id}" - ) as resp: - json_body = resp.json() - - # если получен результат решения капчи, а не информация об отсутсвии решения - if json_body.get("status") != "processing": - return json_body - else: - # ставим небольшую задержку что бы не спамить сервер rabbitmq - time.sleep(requests_timeout) - # уменьшаем счётчик попыток - attempts -= 1 - - return False - - def captcha_handler(self, requests_timeout: int = 1, auth_params: dict = None) -> dict: - """ - Метод отвечает за получение результата решения капчи с callback сервера - :param requests_timeout: Время между запросами к серверу. - :param auth_params: передаются параметры в формате JSON для подключения к удалённому серверу: - { - 'host': '85.255.8.26', - 'port': '8001', - 'rtmq_username': 'hardworker_1', - 'rtmq_password': 'password', - 'rtmq_host': '85.255.8.26', - 'rtmq_port': '5672', - 'rtmq_vhost': 'anticaptcha_vhost', - } - :return: JSON с решением капчи. Формат - {'id':, 'code':} - """ - # если переданы кастомные параметры для подключения к серверу или очереди RabbitMQ - if auth_params: - # кастомные параметры для подключения к серверу - self.host = auth_params["host"] if auth_params.get("host") else self.host - self.port = auth_params["port"] if auth_params.get("port") else self.port - - # кастомные параметры для подключения к очереди - if self.call_type == "queue": - self.rtmq_username = ( - auth_params["rtmq_username"] - if auth_params.get("rtmq_username") - else self.rtmq_username - ) - self.rtmq_password = ( - auth_params["rtmq_password"] - if auth_params.get("rtmq_password") - else self.rtmq_password - ) - self.rtmq_host = ( - auth_params["rtmq_host"] if auth_params.get("rtmq_host") else self.rtmq_host - ) - self.rtmq_port = ( - auth_params["rtmq_port"] if auth_params.get("rtmq_port") else self.rtmq_port - ) - self.rtmq_vhost = ( - auth_params["rtmq_vhost"] if auth_params.get("rtmq_vhost") else self.rtmq_vhost - ) - - # получение данных из кеша - if self.call_type == "cache": - result = self.__handle_cache_message(requests_timeout=requests_timeout) - - # получение данных из очереди - else: - result = self.__handle_queue_message(requests_timeout=requests_timeout) - - # если результат не был получен - if not result: - result = { - "taskId": self.task_id, - "message": {"taskId": self.task_id, "status": "processing"}, - } - - return result diff --git a/python3_anticaptcha/CustomCaptchaTask.py b/python3_anticaptcha/CustomCaptchaTask.py index 00b632d..ff53f53 100644 --- a/python3_anticaptcha/CustomCaptchaTask.py +++ b/python3_anticaptcha/CustomCaptchaTask.py @@ -17,13 +17,13 @@ class CustomCaptchaTask: callbackUrl: str = None, ): """ - Модуль отвечает за решение CustomCaptchaTask - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение CustomCaptchaTask + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param assignment: Опишите что работник должен сделать на английском языке :param forms: Произвольная форма в формате JSON :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -59,11 +59,11 @@ class CustomCaptchaTask: # Работа с капчёй def captcha_handler(self, imageUrl: str, **kwargs) -> dict: """ - Метод получает ссылку изображение для задания - :param imageUrl: URL картинки + Метод получает ссылку изображение для задания + :param imageUrl: URL картинки :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"imageUrl": imageUrl}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи @@ -96,13 +96,13 @@ class aioCustomCaptchaTask: callbackUrl: str = None, ): """ - Модуль отвечает за решение CustomCaptchaTask - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение CustomCaptchaTask + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param assignment: Опишите что работник должен сделать на английском языке :param forms: Произвольная форма в формате JSON :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -138,10 +138,10 @@ class aioCustomCaptchaTask: # Работа с капчёй async def captcha_handler(self, imageUrl: str) -> dict: """ - Метод получает ссылку изображение для задания - :param imageUrl: URL картинки - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + Метод получает ссылку изображение для задания + :param imageUrl: URL картинки + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"imageUrl": imageUrl}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи @@ -164,6 +164,4 @@ class aioCustomCaptchaTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/CustomResultHandler.py b/python3_anticaptcha/CustomResultHandler.py index e1f7416..31fb2f5 100644 --- a/python3_anticaptcha/CustomResultHandler.py +++ b/python3_anticaptcha/CustomResultHandler.py @@ -69,6 +69,4 @@ class aioCustomResultHandler: # wait captcha solution result await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/FunCaptchaTask.py b/python3_anticaptcha/FunCaptchaTask.py index 61313ca..e2d190b 100644 --- a/python3_anticaptcha/FunCaptchaTask.py +++ b/python3_anticaptcha/FunCaptchaTask.py @@ -8,16 +8,14 @@ from python3_anticaptcha import app_key, create_task_url, get_sync_result, get_a class FunCaptchaTask: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): """ - Модуль отвечает за решение FunCaptcha - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение FunCaptcha + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_fun_example.py - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -52,20 +50,16 @@ class FunCaptchaTask: # Работа с капчёй def captcha_handler(self, websiteURL: str, websitePublicKey: str, **kwargs) -> dict: """ - Метод получает ссылку на страницу на которпой расположена капча и ключ капчи - :param websiteURL: Ссылка на страницу с капчёй - :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) + Метод получает ссылку на страницу на которпой расположена капча и ключ капчи + :param websiteURL: Ссылка на страницу с капчёй + :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ - self.task_payload["task"].update( - {"websiteURL": websiteURL, "websitePublicKey": websitePublicKey} - ) + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ + self.task_payload["task"].update({"websiteURL": websiteURL, "websitePublicKey": websitePublicKey}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -85,16 +79,14 @@ class FunCaptchaTask: class aioFunCaptchaTask: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): """ - Модуль отвечает за решение FunCaptcha - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение FunCaptcha + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_fun_example.py - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -129,14 +121,12 @@ class aioFunCaptchaTask: # Работа с капчёй async def captcha_handler(self, websiteURL: str, websitePublicKey: str) -> dict: """ - Метод получает ссылку на страницу на которпой расположена капча и ключ капчи - :param websiteURL: Ссылка на страницу с капчёй - :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ - self.task_payload["task"].update( - {"websiteURL": websiteURL, "websitePublicKey": websitePublicKey} - ) + Метод получает ссылку на страницу на которпой расположена капча и ключ капчи + :param websiteURL: Ссылка на страницу с капчёй + :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ + self.task_payload["task"].update({"websiteURL": websiteURL, "websitePublicKey": websitePublicKey}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи async with aiohttp.ClientSession() as session: @@ -158,6 +148,4 @@ class aioFunCaptchaTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/FunCaptchaTaskProxyless.py b/python3_anticaptcha/FunCaptchaTaskProxyless.py index 0c5c635..c90d892 100644 --- a/python3_anticaptcha/FunCaptchaTaskProxyless.py +++ b/python3_anticaptcha/FunCaptchaTaskProxyless.py @@ -10,11 +10,11 @@ from python3_anticaptcha import app_key, create_task_url, get_sync_result, get_a class FunCaptchaTaskProxyless: def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None): """ - Модуль отвечает за решение FunCaptcha Proxyless - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение FunCaptcha Proxyless + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -44,21 +44,19 @@ class FunCaptchaTaskProxyless: # Работа с капчёй def captcha_handler(self, websiteURL: str, data: str, websitePublicKey: str, **kwargs) -> dict: """ - Метод получает ссылку на страницу на которпой расположена капча и ключ капчи - :param websiteURL: Ссылка на страницу с капчёй - :param data: Дополнительный параметр, который может требоваться для некоторых решений фанкапчи. - :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) + Метод получает ссылку на страницу на которпой расположена капча и ключ капчи + :param websiteURL: Ссылка на страницу с капчёй + :param data: Дополнительный параметр, который может требоваться для некоторых решений фанкапчи. + :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update( {"websiteURL": websiteURL, "data": data, "websitePublicKey": websitePublicKey} ) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -80,11 +78,11 @@ class FunCaptchaTaskProxyless: class aioFunCaptchaTaskProxyless: def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None): """ - Модуль отвечает за решение FunCaptcha Proxyless - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение FunCaptcha Proxyless + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -106,12 +104,12 @@ class aioFunCaptchaTaskProxyless: # Работа с капчёй async def captcha_handler(self, websiteURL: str, data: str, websitePublicKey: str) -> dict: """ - Метод получает ссылку на страницу на которпой расположена капча и ключ капчи - :param websiteURL: Ссылка на страницу с капчёй - :param data: Дополнительный параметр, который может требоваться для некоторых решений фанкапчи. - :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + Метод получает ссылку на страницу на которпой расположена капча и ключ капчи + :param websiteURL: Ссылка на страницу с капчёй + :param data: Дополнительный параметр, который может требоваться для некоторых решений фанкапчи. + :param websitePublicKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update( {"websiteURL": websiteURL, "data": data, "websitePublicKey": websitePublicKey} ) @@ -136,6 +134,4 @@ class aioFunCaptchaTaskProxyless: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/GeeTestTask.py b/python3_anticaptcha/GeeTestTask.py index 0c7954d..b7e1ece 100644 --- a/python3_anticaptcha/GeeTestTask.py +++ b/python3_anticaptcha/GeeTestTask.py @@ -18,14 +18,14 @@ class GeeTestTask: **kwargs, ): """ - Модуль отвечает за решение GeeTestTask - :param anticaptcha_key: Ключ от АнтиКапчи - :param websiteURL: Адрес страницы на которой решается капча + Модуль отвечает за решение GeeTestTask + :param anticaptcha_key: Ключ от АнтиКапчи + :param websiteURL: Адрес страницы на которой решается капча :param gt: Ключ-индентификатор капчи на целевой странице - :param sleep_time: Время ожидания решения + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_gee_test_task.py - """ + """ if sleep_time < 10: raise ValueError(f"Param `sleep_time` must be greater than 10. U set - {sleep_time}") self.sleep_time = sleep_time @@ -60,17 +60,15 @@ class GeeTestTask: # Работа с капчёй def captcha_handler(self, challenge: str, **kwargs) -> dict: """ - Метод получает ссылку изображение для задания - :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи + Метод получает ссылку изображение для задания + :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"challenge": challenge}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -100,14 +98,14 @@ class aioGeeTestTask: **kwargs, ): """ - Модуль отвечает за решение GeeTestTask - :param anticaptcha_key: Ключ от АнтиКапчи - :param websiteURL: Адрес страницы на которой решается капча + Модуль отвечает за решение GeeTestTask + :param anticaptcha_key: Ключ от АнтиКапчи + :param websiteURL: Адрес страницы на которой решается капча :param gt: Ключ-индентификатор капчи на целевой странице - :param sleep_time: Время ожидания решения + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_gee_test_task.py - """ + :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_gee_test_task.py + """ if sleep_time < 10: raise ValueError(f"Param `sleep_time` must be greater than 10. U set - {sleep_time}") self.sleep_time = sleep_time @@ -142,10 +140,10 @@ class aioGeeTestTask: # Работа с капчёй async def captcha_handler(self, challenge: str) -> dict: """ - Метод получает ссылку изображение для задания - :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + Метод получает ссылку изображение для задания + :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"challenge": challenge}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи @@ -168,6 +166,4 @@ class aioGeeTestTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/GeeTestTaskProxyless.py b/python3_anticaptcha/GeeTestTaskProxyless.py index 264b331..284edfc 100644 --- a/python3_anticaptcha/GeeTestTaskProxyless.py +++ b/python3_anticaptcha/GeeTestTaskProxyless.py @@ -17,13 +17,13 @@ class GeeTestTaskProxyless: callbackUrl: str = None, ): """ - Модуль отвечает за решение GeeTestTaskProxyless - :param anticaptcha_key: Ключ от АнтиКапчи - :param websiteURL: Адрес страницы на которой решается капча + Модуль отвечает за решение GeeTestTaskProxyless + :param anticaptcha_key: Ключ от АнтиКапчи + :param websiteURL: Адрес страницы на которой решается капча :param gt: Ключ-индентификатор капчи на целевой странице - :param sleep_time: Время ожидания решения + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 10: raise ValueError(f"Param `sleep_time` must be greater than 10. U set - {sleep_time}") self.sleep_time = sleep_time @@ -52,17 +52,15 @@ class GeeTestTaskProxyless: # Работа с капчёй def captcha_handler(self, challenge: str, **kwargs) -> dict: """ - Метод получает ссылку изображение для задания - :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи + Метод получает ссылку изображение для задания + :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"challenge": challenge}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -91,13 +89,13 @@ class aioGeeTestTaskProxyless: callbackUrl: str = None, ): """ - Модуль отвечает за решение GeeTestTaskProxyless - :param anticaptcha_key: Ключ от АнтиКапчи - :param websiteURL: Адрес страницы на которой решается капча + Модуль отвечает за решение GeeTestTaskProxyless + :param anticaptcha_key: Ключ от АнтиКапчи + :param websiteURL: Адрес страницы на которой решается капча :param gt: Ключ-индентификатор капчи на целевой странице - :param sleep_time: Время ожидания решения + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 10: raise ValueError(f"Param `sleep_time` must be greater than 10. U set - {sleep_time}") self.sleep_time = sleep_time @@ -126,10 +124,10 @@ class aioGeeTestTaskProxyless: # Работа с капчёй async def captcha_handler(self, challenge: str) -> dict: """ - Метод получает ссылку изображение для задания - :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + Метод получает ссылку изображение для задания + :param challenge: Переменный токен который необходимо обновлять каждый раз перед созданием задачи + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"challenge": challenge}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи @@ -152,6 +150,4 @@ class aioGeeTestTaskProxyless: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/HCaptchaTask.py b/python3_anticaptcha/HCaptchaTask.py index 3f04509..150be64 100644 --- a/python3_anticaptcha/HCaptchaTask.py +++ b/python3_anticaptcha/HCaptchaTask.py @@ -8,18 +8,15 @@ from python3_anticaptcha import app_key, create_task_url, get_sync_result, get_a class HCaptchaTask: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): """ - Модуль отвечает за решение HCaptchaTask - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение HCaptchaTask + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. - Подробнее в официальной документации или примерe - ./anticaptcha_examples/anticaptcha_hcaptcha_example.py - """ + Подробнее в официальной документации или примерe ./anticaptcha_examples/anticaptcha_hcaptcha_example.py + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -62,9 +59,7 @@ class HCaptchaTask: self.task_payload["task"].update({"websiteURL": websiteURL, "websiteKey": websiteKey}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -84,18 +79,16 @@ class HCaptchaTask: class aioHCaptchaTask: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): """ - Модуль отвечает за решение HCaptcha - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение HCaptcha + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe ./anticaptcha_examples/anticaptcha_hcaptcha_example.py - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -156,6 +149,4 @@ class aioHCaptchaTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/HCaptchaTaskProxyless.py b/python3_anticaptcha/HCaptchaTaskProxyless.py index 2f48a43..571edef 100644 --- a/python3_anticaptcha/HCaptchaTaskProxyless.py +++ b/python3_anticaptcha/HCaptchaTaskProxyless.py @@ -10,11 +10,11 @@ from python3_anticaptcha import app_key, create_task_url, get_sync_result, get_a class HCaptchaTaskProxyless: def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None): """ - Модуль отвечает за решение HCaptcha Proxyless - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение HCaptcha Proxyless + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -42,18 +42,16 @@ class HCaptchaTaskProxyless: def captcha_handler(self, websiteURL: str, websiteKey: str, **kwargs) -> dict: """ - Метод получает ссылку на страницу на которпой расположена капча и ключ капчи - :param websiteURL: Адрес страницы на которой решается капча - :param websiteKey: Ключ-индентификатор капчи на целевой странице. - :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) - """ + Метод получает ссылку на страницу на которпой расположена капча и ключ капчи + :param websiteURL: Адрес страницы на которой решается капча + :param websiteKey: Ключ-индентификатор капчи на целевой странице. + :param kwargs: Дополнительные параметры для `requests.post(....)`. + :return: Возвращает ответ сервера в виде JSON(ответ так же можно глянуть в документации антикапчи) + """ self.task_payload["task"].update({"websiteURL": websiteURL, "websiteKey": websiteKey}) # Отправляем на антикапча параметры фанкапич, # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, # иначе возвращаем ответ сервера @@ -76,11 +74,11 @@ class HCaptchaTaskProxyless: class aioHCaptchaTaskProxyless: def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None): """ - Модуль отвечает за решение HCaptcha Proxyless - :param anticaptcha_key: Ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + Модуль отвечает за решение HCaptcha Proxyless + :param anticaptcha_key: Ключ от АнтиКапчи + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback - """ + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -129,6 +127,4 @@ class aioHCaptchaTaskProxyless: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/ImageToTextTask.py b/python3_anticaptcha/ImageToTextTask.py index 9e44db5..a73a0e2 100644 --- a/python3_anticaptcha/ImageToTextTask.py +++ b/python3_anticaptcha/ImageToTextTask.py @@ -31,7 +31,6 @@ class ImageToTextTask: anticaptcha_key: str, sleep_time: int = 5, save_format: str = "temp", - language: str = "en", callbackUrl: str = None, **kwargs, ): @@ -42,7 +41,6 @@ class ImageToTextTask: :param sleep_time: Вермя ожидания решения капчи :param save_format: Формат в котором будет сохраняться изображение, либо как временный файл - 'temp', либо как обычное изображение в папку созданную библиотекой - 'const'. - :param language: Язык капчи :param callbackUrl: URL для решения капчи с ответом через callback :param **kwargs: За подробной информацией обратитесь к документации на сайте anticaptcha. """ @@ -122,9 +120,7 @@ class ImageToTextTask: with open(os.path.join(img_path, "im-{0}.png".format(image_hash)), "rb") as captcha_image: # Добавляем в пайлоад картинку и отправляем - self.task_payload["task"].update( - {"body": base64.b64encode(captcha_image.read()).decode("utf-8")} - ) + self.task_payload["task"].update({"body": base64.b64encode(captcha_image.read()).decode("utf-8")}) # Отправляем на антикапча изображение капчи и другие парметры, # в результате получаем JSON ответ содержащий номер решаемой капчи captcha_id = self.session.post(create_task_url, json=self.task_payload).json() @@ -216,30 +212,28 @@ class ImageToTextTask: class aioImageToTextTask: """ - Данный метод подходит для всинхронного решения капчи-изображение. - Подробней информацию смотрите в методе 'captcha_handler' и '__init__' - """ + Данный метод подходит для всинхронного решения капчи-изображение. + Подробней информацию смотрите в методе 'captcha_handler' и '__init__' + """ def __init__( self, anticaptcha_key: str, sleep_time: int = 5, save_format: str = "temp", - language: str = "en", callbackUrl: str = None, **kwargs, ): """ - Инициализация нужных переменных, создание папки для изображений и кэша - После завершения работы - удаляются временные фалйы и папки - :param anticaptcha_key: АПИ ключ капчи из кабинета пользователя - :param sleep_time: Вермя ожидания решения капчи - :param save_format: Формат в котором будет сохраняться изображение, либо как временный файл - 'temp', - либо как обычное изображение в папку созданную библиотекой - 'const'. - :param language: Язык капчи - :param callbackUrl: URL для решения капчи с ответом через callback - :param **kwargs: За подробной информацией обратитесь к документации на сайте anticaptcha. - """ + Инициализация нужных переменных, создание папки для изображений и кэша + После завершения работы - удаляются временные фалйы и папки + :param anticaptcha_key: АПИ ключ капчи из кабинета пользователя + :param sleep_time: Вермя ожидания решения капчи + :param save_format: Формат в котором будет сохраняться изображение, либо как временный файл - 'temp', + либо как обычное изображение в папку созданную библиотекой - 'const'. + :param callbackUrl: URL для решения капчи с ответом через callback + :param **kwargs: За подробной информацией обратитесь к документации на сайте anticaptcha. + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -282,17 +276,15 @@ class aioImageToTextTask: async def __image_temp_saver(self, captcha_link: str): """ - Метод сохраняет файл изображения как временный и отправляет его сразу на сервер для расшифровки. - :return: Возвращает ID капчи - """ + Метод сохраняет файл изображения как временный и отправляет его сразу на сервер для расшифровки. + :return: Возвращает ID капчи + """ # Скачиваем капчу async with aiohttp.ClientSession() as session: async with session.get(captcha_link) as resp: content = await resp.content.read() # Создаём пайлоад, вводим ключ от сайта, выбираем метод ПОСТ и ждём ответа в JSON-формате - self.task_payload["task"].update( - {"body": base64.b64encode(content).decode("utf-8")} - ) + self.task_payload["task"].update({"body": base64.b64encode(content).decode("utf-8")}) # Отправляем на рукапча изображение капчи и другие парметры, # в результате получаем JSON ответ с номером решаемой капчи async with aiohttp.ClientSession() as session: @@ -301,9 +293,9 @@ class aioImageToTextTask: async def __image_const_saver(self, captcha_link: str): """ - Метод создаёт папку и сохраняет в неё изображение, затем передаёт его на расшифровку и удалет файл. - :return: Возвращает ID капчи - """ + Метод создаёт папку и сохраняет в неё изображение, затем передаёт его на расшифровку и удалет файл. + :return: Возвращает ID капчи + """ img_path = "PythonAntiCaptchaImages" if not os.path.exists(img_path): @@ -322,9 +314,7 @@ class aioImageToTextTask: with open(os.path.join(img_path, "im-{0}.png".format(image_hash)), "rb") as captcha_image: # Добавляем в пайлоад картинку и отправляем - self.task_payload["task"].update( - {"body": base64.b64encode(captcha_image.read()).decode("utf-8")} - ) + self.task_payload["task"].update({"body": base64.b64encode(captcha_image.read()).decode("utf-8")}) # Отправляем на антикапча изображение капчи и другие парметры, # в результате получаем JSON ответ содержащий номер решаемой капчи @@ -372,18 +362,16 @@ class aioImageToTextTask: self, captcha_link: str = None, captcha_file: str = None, captcha_base64: str = None ) -> dict: """ - Метод получает от вас ссылку на изображение, скачивает его, отправляет изображение на сервер - RuCaptcha, дожидается решения капчи и вовзращает вам результат - :param captcha_link: Ссылка на изображение - :return: Возвращает весь ответ сервера JSON-строкой. - """ + Метод получает от вас ссылку на изображение, скачивает его, отправляет изображение на сервер + RuCaptcha, дожидается решения капчи и вовзращает вам результат + :param captcha_link: Ссылка на изображение + :return: Возвращает весь ответ сервера JSON-строкой. + """ # если был передан линк на локальный скачаный файл if captcha_file: captcha_id = await self.__read_captcha_image_file(captcha_file, content_type="file") elif captcha_base64: - captcha_id = await self.__read_captcha_image_file( - captcha_base64, content_type="base64" - ) + captcha_id = await self.__read_captcha_image_file(captcha_base64, content_type="base64") elif captcha_link: # согласно значения переданного параметра выбираем функцию для сохранения изображения if self.save_format == SAVE_FORMATS[0]: @@ -410,6 +398,4 @@ class aioImageToTextTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/NoCaptchaTask.py b/python3_anticaptcha/NoCaptchaTask.py index 527f39c..1707630 100644 --- a/python3_anticaptcha/NoCaptchaTask.py +++ b/python3_anticaptcha/NoCaptchaTask.py @@ -8,13 +8,11 @@ from python3_anticaptcha import app_key, create_task_url, get_sync_result, get_a class NoCaptchaTask: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 10, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 10, callbackUrl: str = None, **kwargs): """ Модуль отвечает за решение NoCaptcha. :param anticaptcha_key: ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_nocaptcha_example.py """ @@ -57,7 +55,7 @@ class NoCaptchaTask: Метод получает ссылку на страницу, где расположена капча, и ключ капчи :param: websiteURL: Ссылка на страницу с капчёй :param: websiteKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи) - :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать + :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать дополнительный параметр "data-s" в div'е рекапчи, который является одноразовым токеном и должен собираться каждый раз при решении рекапчи. @@ -72,9 +70,7 @@ class NoCaptchaTask: } ) # отправляем реквест, в ответ получаем JSON содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -93,13 +89,11 @@ class NoCaptchaTask: class aioNoCaptchaTask: - def __init__( - self, anticaptcha_key: str, sleep_time: str = 10, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: str = 10, callbackUrl: str = None, **kwargs): """ Модуль отвечает за решение NoCaptcha. :param anticaptcha_key: ключ от АнтиКапчи - :param sleep_time: Время ожидания решения + :param sleep_time: Время ожидания решения :param callbackUrl: URL для решения капчи с ответом через callback :param kwargs: Параметры для подключения к прокси. Подробнее в официальной документации или примерe - anticaptcha_examples/anticaptcha_nocaptcha_example.py """ @@ -135,14 +129,12 @@ class aioNoCaptchaTask: return True # Работа с капчей - async def captcha_handler( - self, websiteURL: str, websiteKey: str, recaptchaDataSValue: str = "" - ) -> dict: + async def captcha_handler(self, websiteURL: str, websiteKey: str, recaptchaDataSValue: str = "") -> dict: """ Метод получает ссылку на страницу, где расположена капча, и ключ капчи :param: websiteURL: Ссылка на страницу с капчёй. :param: websiteKey: Ключ капчи(как его получить - описано в документаии на сайте антикапчи). - :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать + :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать дополнительный параметр "data-s" в div'е рекапчи, который является одноразовым токеном и должен собираться каждый раз при решении рекапчи. @@ -174,6 +166,4 @@ class aioNoCaptchaTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/NoCaptchaTaskProxyless.py b/python3_anticaptcha/NoCaptchaTaskProxyless.py index 59b7a71..4f18cfb 100644 --- a/python3_anticaptcha/NoCaptchaTaskProxyless.py +++ b/python3_anticaptcha/NoCaptchaTaskProxyless.py @@ -8,16 +8,14 @@ from python3_anticaptcha import app_key, create_task_url, get_sync_result, get_a class NoCaptchaTaskProxyless: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): """ - Модуль отвечает за решение ReCaptcha без прокси - :param anticaptcha_key: Ключ антикапчи - :param sleep_time: Время ожидания решения капчи + Модуль отвечает за решение ReCaptcha без прокси + :param anticaptcha_key: Ключ антикапчи + :param sleep_time: Время ожидания решения капчи :param callbackUrl: URL для решения капчи с ответом через callback - :param kwargs: Другие необязательные параметры из документации - """ + :param kwargs: Другие необязательные параметры из документации + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -53,16 +51,16 @@ class NoCaptchaTaskProxyless: self, websiteURL: str, websiteKey: str, recaptchaDataSValue: str = "", **kwargs ) -> dict: """ - Метод решения ReCaptcha - :param websiteURL: Ссылка на страницу с капчёй - :param websiteKey: Ключ капчи сайта(как получить - написано в документации) - :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать + Метод решения ReCaptcha + :param websiteURL: Ссылка на страницу с капчёй + :param websiteKey: Ключ капчи сайта(как получить - написано в документации) + :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать дополнительный параметр "data-s" в div'е рекапчи, который является одноразовым токеном и должен собираться каждый раз при решении рекапчи. :param kwargs: Дополнительные параметры для `requests.post(....)`. - :return: Возвращает ответ сервера в виде JSON-строки - """ + :return: Возвращает ответ сервера в виде JSON-строки + """ # вставляем в пайлоад адрес страницы и ключ-индентификатор рекапчи self.task_payload["task"].update( @@ -74,9 +72,7 @@ class NoCaptchaTaskProxyless: ) # Отправляем на антикапчу пайлоад # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -96,16 +92,14 @@ class NoCaptchaTaskProxyless: class aioNoCaptchaTaskProxyless: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): + """ + Модуль отвечает за решение ReCaptcha без прокси + :param anticaptcha_key: Ключ антикапчи + :param sleep_time: Время ожидания решения капчи + :param callbackUrl: URL для решения капчи с ответом через callback + :param kwargs: Другие необязательные параметры из документации """ - Модуль отвечает за решение ReCaptcha без прокси - :param anticaptcha_key: Ключ антикапчи - :param sleep_time: Время ожидания решения капчи - :param callbackUrl: URL для решения капчи с ответом через callback - :param kwargs: Другие необязательные параметры из документации - """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be greater than 5. U set - {sleep_time}") self.sleep_time = sleep_time @@ -138,19 +132,17 @@ class aioNoCaptchaTaskProxyless: return True # Работа с капчёй - async def captcha_handler( - self, websiteURL: str, websiteKey: str, recaptchaDataSValue: str = "" - ) -> dict: + async def captcha_handler(self, websiteURL: str, websiteKey: str, recaptchaDataSValue: str = "") -> dict: + """ + Метод решения ReCaptcha + :param websiteURL: Ссылка на страницу с капчёй + :param websiteKey: Ключ капчи сайта(как получить - написано в документации) + :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать + дополнительный параметр "data-s" в div'е рекапчи, + который является одноразовым токеном и + должен собираться каждый раз при решении рекапчи. + :return: Возвращает ответ сервера в виде JSON-строки """ - Метод решения ReCaptcha - :param websiteURL: Ссылка на страницу с капчёй - :param websiteKey: Ключ капчи сайта(как получить - написано в документации) - :param recaptchaDataSValue: Некоторые реализации виджета рекапчи могут содержать - дополнительный параметр "data-s" в div'е рекапчи, - который является одноразовым токеном и - должен собираться каждый раз при решении рекапчи. - :return: Возвращает ответ сервера в виде JSON-строки - """ # вставляем в пайлоад адрес страницы и ключ-индентификатор рекапчи self.task_payload["task"].update( @@ -180,6 +172,4 @@ class aioNoCaptchaTaskProxyless: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/ReCaptchaV3TaskProxyless.py b/python3_anticaptcha/ReCaptchaV3TaskProxyless.py index edd499e..124d265 100644 --- a/python3_anticaptcha/ReCaptchaV3TaskProxyless.py +++ b/python3_anticaptcha/ReCaptchaV3TaskProxyless.py @@ -10,16 +10,14 @@ MIN_SCORES = (0.3, 0.7, 0.9) class ReCaptchaV3TaskProxyless: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): """ - Модуль отвечает за решение ReCaptcha v3 без прокси - :param anticaptcha_key: Ключ антикапчи - :param sleep_time: Время ожидания решения капчи + Модуль отвечает за решение ReCaptcha v3 без прокси + :param anticaptcha_key: Ключ антикапчи + :param sleep_time: Время ожидания решения капчи :param callbackUrl: URL для решения капчи с ответом через callback - :param kwargs: Другие необязательные параметры из документации - """ + :param kwargs: Другие необязательные параметры из документации + """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be less than 5. U send - {sleep_time}") self.sleep_time = sleep_time @@ -55,19 +53,17 @@ class ReCaptchaV3TaskProxyless: self, websiteURL: str, websiteKey: str, minScore: float, pageAction: str = None, **kwargs ) -> dict: """ - Метод решения ReCaptcha V3 - :param websiteURL: Ссылка на страницу с капчёй - :param websiteKey: Ключ-индентификатор рекапчи на целевой странице. Берется из HTML этой страницы. - :param minScore: Определяет фильтр, по которому отбирается работник с нужным минимальным score. - :param pageAction: Значение параметра action, которое передается виджетом рекапчи в гугл, - и которое потом видит владелец сайта при проверке токена. - :param kwargs: Дополнительные параметры для `requests.post(....)`, который отправляет даныйе на решение. - :return: Возвращает ответ сервера в виде JSON-строки - """ + Метод решения ReCaptcha V3 + :param websiteURL: Ссылка на страницу с капчёй + :param websiteKey: Ключ-индентификатор рекапчи на целевой странице. Берется из HTML этой страницы. + :param minScore: Определяет фильтр, по которому отбирается работник с нужным минимальным score. + :param pageAction: Значение параметра action, которое передается виджетом рекапчи в гугл, + и которое потом видит владелец сайта при проверке токена. + :param kwargs: Дополнительные параметры для `requests.post(....)`, который отправляет даныйе на решение. + :return: Возвращает ответ сервера в виде JSON-строки + """ if minScore not in MIN_SCORES: - raise ValueError( - f"Wrong `minScore` param - {minScore}, available params - {MIN_SCORES};" - ) + raise ValueError(f"Wrong `minScore` param - {minScore}, available params - {MIN_SCORES};") # вставляем в пайлоад адрес страницы и ключ-индентификатор рекапчи self.task_payload["task"].update( { @@ -79,9 +75,7 @@ class ReCaptchaV3TaskProxyless: ) # Отправляем на антикапчу пайлоад # в результате получаем JSON ответ содержащий номер решаемой капчи - captcha_id = requests.post( - create_task_url, json=self.task_payload, verify=False, **kwargs - ).json() + captcha_id = requests.post(create_task_url, json=self.task_payload, verify=False, **kwargs).json() # Проверка статуса создания задачи, если создано без ошибок - извлекаем ID задачи, иначе возвращаем ответ сервера if captcha_id["errorId"] == 0: @@ -101,16 +95,14 @@ class ReCaptchaV3TaskProxyless: class aioReCaptchaV3TaskProxyless: - def __init__( - self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs - ): + def __init__(self, anticaptcha_key: str, sleep_time: int = 5, callbackUrl: str = None, **kwargs): + """ + Модуль отвечает за решение ReCaptcha V3 без прокси + :param anticaptcha_key: Ключ антикапчи + :param sleep_time: Время ожидания решения капчи + :param callbackUrl: URL для решения капчи с ответом через callback + :param kwargs: Другие необязательные параметры из документации """ - Модуль отвечает за решение ReCaptcha V3 без прокси - :param anticaptcha_key: Ключ антикапчи - :param sleep_time: Время ожидания решения капчи - :param callbackUrl: URL для решения капчи с ответом через callback - :param kwargs: Другие необязательные параметры из документации - """ if sleep_time < 5: raise ValueError(f"Param `sleep_time` must be less than 5. U send - {sleep_time}") self.sleep_time = sleep_time @@ -147,18 +139,16 @@ class aioReCaptchaV3TaskProxyless: self, websiteURL: str, websiteKey: str, minScore: float, pageAction: str = None ) -> dict: """ - Метод решения ReCaptcha V3 - :param websiteURL: Ссылка на страницу с капчёй - :param websiteKey: Ключ-индентификатор рекапчи на целевой странице. Берется из HTML этой страницы. - :param minScore: Определяет фильтр, по которому отбирается работник с нужным минимальным score. - :param pageAction: Значение параметра action, которое передается виджетом рекапчи в гугл, - и которое потом видит владелец сайта при проверке токена. - :return: Возвращает ответ сервера в виде JSON-строки - """ + Метод решения ReCaptcha V3 + :param websiteURL: Ссылка на страницу с капчёй + :param websiteKey: Ключ-индентификатор рекапчи на целевой странице. Берется из HTML этой страницы. + :param minScore: Определяет фильтр, по которому отбирается работник с нужным минимальным score. + :param pageAction: Значение параметра action, которое передается виджетом рекапчи в гугл, + и которое потом видит владелец сайта при проверке токена. + :return: Возвращает ответ сервера в виде JSON-строки + """ if minScore not in MIN_SCORES: - raise ValueError( - f"Wrong `minScore` param - {minScore}, available params - {MIN_SCORES};" - ) + raise ValueError(f"Wrong `minScore` param - {minScore}, available params - {MIN_SCORES};") # вставляем в пайлоад адрес страницы и ключ-индентификатор рекапчи self.task_payload["task"].update( { @@ -188,6 +178,4 @@ class aioReCaptchaV3TaskProxyless: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/SquareNetTextTask.py b/python3_anticaptcha/SquareNetTextTask.py index 3988999..16ed25c 100644 --- a/python3_anticaptcha/SquareNetTextTask.py +++ b/python3_anticaptcha/SquareNetTextTask.py @@ -113,9 +113,7 @@ class SquareNetTextTask: with open(os.path.join(img_path, "im-{0}.png".format(image_hash)), "rb") as captcha_image: # Добавляем в пайлоад картинку и отправляем - self.task_payload["task"].update( - {"body": base64.b64encode(captcha_image.read()).decode("utf-8")} - ) + self.task_payload["task"].update({"body": base64.b64encode(captcha_image.read()).decode("utf-8")}) # Отправляем на антикапча изображение капчи и другие парметры, # в результате получаем JSON ответ содержащий номер решаемой капчи captcha_id = self.session.post(create_task_url, json=self.task_payload).json() @@ -234,9 +232,9 @@ class SquareNetTextTask: class aioSquareNetTextTask: """ - Данный метод подходит для всинхронного решения капчи-изображение. - Подробней информацию смотрите в методе 'captcha_handler' и '__init__' - """ + Данный метод подходит для всинхронного решения капчи-изображение. + Подробней информацию смотрите в методе 'captcha_handler' и '__init__' + """ def __init__( self, @@ -290,17 +288,15 @@ class aioSquareNetTextTask: async def __image_temp_saver(self, captcha_link: str): """ - Метод сохраняет файл изображения как временный и отправляет его сразу на сервер для расшифровки. - :return: Возвращает ID капчи - """ + Метод сохраняет файл изображения как временный и отправляет его сразу на сервер для расшифровки. + :return: Возвращает ID капчи + """ # Скачиваем капчу async with aiohttp.ClientSession() as session: async with session.get(captcha_link) as resp: content = await resp.content.read() # Создаём пайлоад, вводим ключ от сайта, выбираем метод ПОСТ и ждём ответа в JSON-формате - self.task_payload["task"].update( - {"body": base64.b64encode(content).decode("utf-8")} - ) + self.task_payload["task"].update({"body": base64.b64encode(content).decode("utf-8")}) # Отправляем на рукапча изображение капчи и другие парметры, # в результате получаем JSON ответ с номером решаемой капчи async with aiohttp.ClientSession() as session: @@ -309,9 +305,9 @@ class aioSquareNetTextTask: async def __image_const_saver(self, captcha_link: str): """ - Метод создаёт папку и сохраняет в неё изображение, затем передаёт его на расшифровку и удалет файл. - :return: Возвращает ID капчи - """ + Метод создаёт папку и сохраняет в неё изображение, затем передаёт его на расшифровку и удалет файл. + :return: Возвращает ID капчи + """ img_path = "PythonAntiCaptchaImages" if not os.path.exists(img_path): @@ -330,9 +326,7 @@ class aioSquareNetTextTask: with open(os.path.join(img_path, "im-{0}.png".format(image_hash)), "rb") as captcha_image: # Добавляем в пайлоад картинку и отправляем - self.task_payload["task"].update( - {"body": base64.b64encode(captcha_image.read()).decode("utf-8")} - ) + self.task_payload["task"].update({"body": base64.b64encode(captcha_image.read()).decode("utf-8")}) # Отправляем на антикапча изображение капчи и другие парметры, # в результате получаем JSON ответ содержащий номер решаемой капчи async with aiohttp.ClientSession() as session: @@ -437,6 +431,4 @@ class aioSquareNetTextTask: else: # Ждем решения капчи await asyncio.sleep(self.sleep_time) - return await get_async_result( - result_payload=self.result_payload, sleep_time=self.sleep_time - ) + return await get_async_result(result_payload=self.result_payload, sleep_time=self.sleep_time) diff --git a/python3_anticaptcha/__init__.py b/python3_anticaptcha/__init__.py index 89fc837..318232a 100644 --- a/python3_anticaptcha/__init__.py +++ b/python3_anticaptcha/__init__.py @@ -1,11 +1,4 @@ from .config import ( - HOST, - PORT, - RTMQ_HOST, - RTMQ_PORT, - RTMQ_VHOST, - RTMQ_PASSWORD, - RTMQ_USERNAME, app_key, get_result_url, create_task_url, diff --git a/python3_anticaptcha/config.py b/python3_anticaptcha/config.py index b7df56d..da0b3f4 100644 --- a/python3_anticaptcha/config.py +++ b/python3_anticaptcha/config.py @@ -8,17 +8,3 @@ create_task_url = "https://api.anti-captcha.com/createTask" get_result_url = "https://api.anti-captcha.com/getTaskResult" # ключ приложения app_key = "867" - -""" -Параметры для callback -""" -# IP для работы callback`a -HOST = "85.255.8.26" -# PORT для работы callback`a -PORT = 8001 -# данные для подключения к RabbitMQ на callback сервере -RTMQ_USERNAME = "hardworker_1" -RTMQ_PASSWORD = "password" -RTMQ_HOST = "85.255.8.26" -RTMQ_PORT = 5672 -RTMQ_VHOST = "anticaptcha_vhost" diff --git a/setup.py b/setup.py index db858b2..036b813 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ URL = "https://github.com/AndreiDrang/python3-anticaptcha" EMAIL = "drang.andray@gmail.com" AUTHOR = "AndreiDrang, redV0ID" REQUIRES_PYTHON = ">=3.6.0" -VERSION = "1.6.2" +VERSION = "1.7" REQUIRED = ["requests==2.23.0", "aiohttp==3.7.2", "pika==1.1.0"] here = os.path.abspath(os.path.dirname(__file__)) diff --git a/tests/test_Callback.py b/tests/test_Callback.py deleted file mode 100644 index 8e86675..0000000 --- a/tests/test_Callback.py +++ /dev/null @@ -1,16 +0,0 @@ -import requests - -from tests.main import MainAntiCaptcha - - -class TestAntiCaptcha(MainAntiCaptcha): - def test_callback_server(self): - # test server alive - response = requests.get(f"http://{self.server_ip}:8001/ping") - assert response.status_code == 200 - # try register new queue - response = requests.post( - f"http://{self.server_ip}:8001/register_key", - json={"key": "fwefefefopewofkewopfkop", "vhost": "anticaptcha_vhost"}, - ) - assert response.status_code == 200 diff --git a/tests/test_Control.py b/tests/test_Control.py index 46227ec..d127317 100644 --- a/tests/test_Control.py +++ b/tests/test_Control.py @@ -25,12 +25,8 @@ class TestControl(MainAntiCaptcha): default_queue_status_params = ["queue_id"] # get aiocaptchacontrol init and other params aio_init_params = inspect.getfullargspec(AntiCaptchaControl.aioAntiCaptchaControl.__init__) - aio_balance_params = inspect.getfullargspec( - AntiCaptchaControl.aioAntiCaptchaControl.get_balance - ) - aio_app_stats_params = inspect.getfullargspec( - AntiCaptchaControl.aioAntiCaptchaControl.get_app_stats - ) + aio_balance_params = inspect.getfullargspec(AntiCaptchaControl.aioAntiCaptchaControl.get_balance) + aio_app_stats_params = inspect.getfullargspec(AntiCaptchaControl.aioAntiCaptchaControl.get_app_stats) aio_complaint_params = inspect.getfullargspec( AntiCaptchaControl.aioAntiCaptchaControl.complaint_on_result ) @@ -41,15 +37,9 @@ class TestControl(MainAntiCaptcha): # get captchacontrol init and other params init_params = inspect.getfullargspec(AntiCaptchaControl.AntiCaptchaControl.__init__) balance_params = inspect.getfullargspec(AntiCaptchaControl.AntiCaptchaControl.get_balance) - app_stats_params = inspect.getfullargspec( - AntiCaptchaControl.AntiCaptchaControl.get_app_stats - ) - complaint_params = inspect.getfullargspec( - AntiCaptchaControl.AntiCaptchaControl.complaint_on_result - ) - queue_status_params = inspect.getfullargspec( - AntiCaptchaControl.AntiCaptchaControl.get_queue_status - ) + app_stats_params = inspect.getfullargspec(AntiCaptchaControl.AntiCaptchaControl.get_app_stats) + complaint_params = inspect.getfullargspec(AntiCaptchaControl.AntiCaptchaControl.complaint_on_result) + queue_status_params = inspect.getfullargspec(AntiCaptchaControl.AntiCaptchaControl.get_queue_status) # check aio module params assert default_init_params == aio_init_params[0] assert default_get_balance_params == aio_balance_params[0] @@ -83,7 +73,9 @@ class TestControl(MainAntiCaptcha): request_payload = history[0].json() # check all dict keys - assert ["clientKey",] == list(request_payload.keys()) + assert [ + "clientKey", + ] == list(request_payload.keys()) assert request_payload["clientKey"] == self.anticaptcha_key_true def test_stats_payload(self): @@ -115,9 +107,7 @@ class TestControl(MainAntiCaptcha): task_id = 123456 with requests_mock.Mocker() as req_mock: - req_mock.post( - AntiCaptchaControl.incorrect_imagecaptcha_url, json=self.ERROR_RESPONSE_JSON - ) + req_mock.post(AntiCaptchaControl.incorrect_imagecaptcha_url, json=self.ERROR_RESPONSE_JSON) control.complaint_on_result( reported_id=task_id, captcha_type=AntiCaptchaControl.complaint_types[0] ) @@ -140,9 +130,7 @@ class TestControl(MainAntiCaptcha): task_id = 123456 with requests_mock.Mocker() as req_mock: - req_mock.post( - AntiCaptchaControl.incorrect_recaptcha_url, json=self.ERROR_RESPONSE_JSON - ) + req_mock.post(AntiCaptchaControl.incorrect_recaptcha_url, json=self.ERROR_RESPONSE_JSON) control.complaint_on_result( reported_id=task_id, captcha_type=AntiCaptchaControl.complaint_types[1] ) @@ -171,7 +159,9 @@ class TestControl(MainAntiCaptcha): request_payload = history[0].json() # check all dict keys - assert ["queueId",] == list(request_payload.keys()) + assert [ + "queueId", + ] == list(request_payload.keys()) assert request_payload["queueId"] == queue_id """ @@ -179,17 +169,13 @@ class TestControl(MainAntiCaptcha): """ def test_response_control(self): - control_captcha = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + control_captcha = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) # check response type assert isinstance(control_captcha, AntiCaptchaControl.AntiCaptchaControl) @pytest.mark.asyncio async def test_response_aiocontrol(self): - control_captcha = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + control_captcha = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) # check response type assert isinstance(control_captcha, AntiCaptchaControl.aioAntiCaptchaControl) @@ -198,9 +184,7 @@ class TestControl(MainAntiCaptcha): """ def test_fail_balance(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) response = captcha_control.get_balance() @@ -220,9 +204,7 @@ class TestControl(MainAntiCaptcha): assert 1 == response["errorId"] def test_fail_key_app_stats(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) response = captcha_control.get_app_stats(softId=self.WRONG_SOFT_ID) @@ -242,9 +224,7 @@ class TestControl(MainAntiCaptcha): assert 1 == response["errorId"] def test_fail_id_app_stats(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = captcha_control.get_app_stats(softId=self.WRONG_SOFT_ID) @@ -253,16 +233,12 @@ class TestControl(MainAntiCaptcha): assert 1 == response["errorId"] def test_fail_mode_app_stats(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) with pytest.raises(ValueError): assert captcha_control.get_app_stats(softId=config.app_key, mode=self.WRONG_MODE) def test_fail_key_complaint(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) response = captcha_control.complaint_on_result( reported_id=self.REPORT_ID, captcha_type=AntiCaptchaControl.complaint_types[0] @@ -273,9 +249,7 @@ class TestControl(MainAntiCaptcha): assert 1 == response["errorId"] def test_fail_id_complaint(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = captcha_control.complaint_on_result( reported_id=self.REPORT_ID, captcha_type=AntiCaptchaControl.complaint_types[0] @@ -286,9 +260,7 @@ class TestControl(MainAntiCaptcha): assert 16 == response["errorId"] def test_fail_type_complaint(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) with pytest.raises(ValueError): assert captcha_control.complaint_on_result( @@ -303,9 +275,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aiobalance(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) response = await captcha_control.get_balance() @@ -339,9 +309,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aiokey_app_stats(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) response = await captcha_control.get_app_stats(softId=self.WRONG_SOFT_ID) @@ -351,9 +319,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aioid_app_stats(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = await captcha_control.get_app_stats(softId=self.WRONG_SOFT_ID) @@ -375,9 +341,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aiokey_complaint(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) response = await captcha_control.complaint_on_result( reported_id=self.REPORT_ID, captcha_type=AntiCaptchaControl.complaint_types[0] @@ -389,9 +353,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aioid_complaint(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = await captcha_control.complaint_on_result( reported_id=self.REPORT_ID, captcha_type=AntiCaptchaControl.complaint_types[0] @@ -403,9 +365,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aiotype_complaint(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_fail - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_fail) with pytest.raises(ValueError): assert await captcha_control.complaint_on_result( @@ -420,17 +380,13 @@ class TestControl(MainAntiCaptcha): assert await captcha_control.get_queue_status(queue_id=self.WRONG_QUEUE_ID) def test_fail_spend_stats_queue(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) with pytest.raises(ValueError): captcha_control.get_spend_stats(queue=self.WRONG_QUEUE) @pytest.mark.asyncio async def test_fail_aiospend_stats_queue(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) with pytest.raises(ValueError): await captcha_control.get_spend_stats(queue=self.WRONG_QUEUE) @@ -439,9 +395,7 @@ class TestControl(MainAntiCaptcha): """ def test_true_mode_app_stats(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) for mode in AntiCaptchaControl.mods: response = captcha_control.get_app_stats(softId=config.app_key, mode=mode) @@ -463,9 +417,7 @@ class TestControl(MainAntiCaptcha): assert 0 == response["errorId"] def test_true_balance(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = captcha_control.get_balance() @@ -494,9 +446,7 @@ class TestControl(MainAntiCaptcha): assert self.QUEUE_STATUS_KEYS == tuple(response.keys()) def test_true_spend_stats(self): - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = captcha_control.get_spend_stats() assert isinstance(response, dict) @@ -506,9 +456,7 @@ class TestControl(MainAntiCaptcha): def test_true_spend_stats_queues(self): queues = AntiCaptchaControl.queues_names - captcha_control = AntiCaptchaControl.AntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.AntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) for queue in queues: response = captcha_control.get_spend_stats(queue=queue) @@ -528,9 +476,7 @@ class TestControl(MainAntiCaptcha): @pytest.mark.asyncio async def test_true_aiospend_stats(self): - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) response = await captcha_control.get_spend_stats() assert isinstance(response, dict) @@ -552,9 +498,7 @@ class TestControl(MainAntiCaptcha): async def test_true_aiospend_stats_queues(self): queues = AntiCaptchaControl.queues_names - captcha_control = AntiCaptchaControl.aioAntiCaptchaControl( - anticaptcha_key=self.anticaptcha_key_true - ) + captcha_control = AntiCaptchaControl.aioAntiCaptchaControl(anticaptcha_key=self.anticaptcha_key_true) for queue in queues: response = await captcha_control.get_spend_stats(queue=queue) diff --git a/tests/test_CustomCaptcha.py b/tests/test_CustomCaptcha.py deleted file mode 100644 index b47ec36..0000000 --- a/tests/test_CustomCaptcha.py +++ /dev/null @@ -1,200 +0,0 @@ -import inspect - -import pytest -import requests_mock - -from tests.main import MainAntiCaptcha -from python3_anticaptcha import CustomCaptchaTask, config - - -class TestCustom(MainAntiCaptcha): - CUSTOM_TASK = "2+2=?" - - """ - Params check - """ - - def test_customcatpcha_params(self): - default_init_params = [ - "self", - "anticaptcha_key", - "sleep_time", - "assignment", - "forms", - "callbackUrl", - ] - default_handler_params = ["self", "imageUrl"] - # get customcaptcha init and captcha_handler params - aioinit_params = inspect.getfullargspec(CustomCaptchaTask.aioCustomCaptchaTask.__init__) - aiohandler_params = inspect.getfullargspec( - CustomCaptchaTask.aioCustomCaptchaTask.captcha_handler - ) - - # get customcaptcha init and captcha_handler params - init_params = inspect.getfullargspec(CustomCaptchaTask.CustomCaptchaTask.__init__) - handler_params = inspect.getfullargspec( - CustomCaptchaTask.CustomCaptchaTask.captcha_handler - ) - # check aio module params - assert default_init_params == aioinit_params[0] - assert default_handler_params == aiohandler_params[0] - # check sync module params - assert default_init_params == init_params[0] - assert default_handler_params == handler_params[0] - - def test_create_task_payload(self): - customcaptcha = CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) - # check response type - assert isinstance(customcaptcha, CustomCaptchaTask.CustomCaptchaTask) - - with requests_mock.Mocker() as req_mock: - req_mock.post(config.create_task_url, json=self.ERROR_RESPONSE_JSON) - customcaptcha.captcha_handler(imageUrl=self.image_url) - - history = req_mock.request_history - - assert len(history) == 1 - - request_payload = history[0].json() - - # check all dict keys - assert ["clientKey", "task", "softId"] == list(request_payload.keys()) - assert request_payload["softId"] == config.app_key - assert ["type", "assignment", "imageUrl"] == list(request_payload["task"].keys()) - assert request_payload["task"]["type"] == "CustomCaptchaTask" - - def test_get_result_payload(self): - customcaptcha = CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) - # check response type - assert isinstance(customcaptcha, CustomCaptchaTask.CustomCaptchaTask) - - with requests_mock.Mocker() as req_mock: - req_mock.register_uri("POST", config.create_task_url, json=self.VALID_RESPONSE_JSON) - req_mock.register_uri( - "POST", config.get_result_url, json=self.VALID_RESPONSE_RESULT_JSON - ) - customcaptcha.captcha_handler(imageUrl=self.image_url) - - history = req_mock.request_history - - assert len(history) == 2 - - request_payload = history[1].json() - - # check all dict keys - assert ["clientKey", "taskId"] == list(request_payload.keys()) - assert request_payload["taskId"] == self.VALID_RESPONSE_JSON["taskId"] - - """ - Response checking - """ - - def test_response_customcaptcha(self): - customcaptcha = CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) - # check response type - assert isinstance(customcaptcha, CustomCaptchaTask.CustomCaptchaTask) - - with requests_mock.Mocker() as req_mock: - req_mock.post(config.create_task_url, json=self.ERROR_RESPONSE_JSON) - response = customcaptcha.captcha_handler(imageUrl=self.image_url) - - # check response type - assert isinstance(response, dict) - # check all dict keys - assert ["errorId", "errorCode", "errorDescription"] == list(response.keys()) - - @pytest.mark.asyncio - async def test_response_aiocustomcaptcha(self): - customcaptcha = CustomCaptchaTask.aioCustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) - # check response type - assert isinstance(customcaptcha, CustomCaptchaTask.aioCustomCaptchaTask) - - response = await customcaptcha.captcha_handler(imageUrl=self.image_url) - # check response type - assert isinstance(response, dict) - # check all dict keys - assert ["errorId", "errorCode", "errorDescription"] == list(response.keys()) - - """ - Fail tests - """ - - def test_fail_customcaptcha(self): - customcaptcha = CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) - - response = customcaptcha.captcha_handler(imageUrl=self.image_url) - - assert 1 == response["errorId"] - - def test_fail_customcaptcha_context(self): - with CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) as customcaptcha: - - response = customcaptcha.captcha_handler(imageUrl=self.image_url) - - assert 1 == response["errorId"] - - @pytest.mark.asyncio - async def test_fail_aiocustomcaptcha(self): - customcaptcha = CustomCaptchaTask.aioCustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) - response = await customcaptcha.captcha_handler(imageUrl=self.image_url) - assert 1 == response["errorId"] - - @pytest.mark.asyncio - async def test_fail_aiocustomcaptcha_context(self): - with CustomCaptchaTask.aioCustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_fail, assignment=self.CUSTOM_TASK - ) as customcaptcha: - response = await customcaptcha.captcha_handler(imageUrl=self.image_url) - assert 1 == response["errorId"] - - """ - True tests - """ - - def test_true_customcaptcha(self): - customcaptcha = CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_true, assignment=self.CUSTOM_TASK - ) - - response = customcaptcha.captcha_handler(imageUrl=self.image_url) - - assert 0 == response["errorId"] - - def test_true_customcaptcha_context(self): - with CustomCaptchaTask.CustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_true, assignment=self.CUSTOM_TASK - ) as customcaptcha: - - response = customcaptcha.captcha_handler(imageUrl=self.image_url) - - assert 0 == response["errorId"] - - @pytest.mark.asyncio - async def test_true_aiocustomcaptcha(self): - customcaptcha = CustomCaptchaTask.aioCustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_true, assignment=self.CUSTOM_TASK - ) - response = await customcaptcha.captcha_handler(imageUrl=self.image_url) - assert 0 == response["errorId"] - - @pytest.mark.asyncio - async def test_true_aiocustomcaptcha_context(self): - with CustomCaptchaTask.aioCustomCaptchaTask( - anticaptcha_key=self.anticaptcha_key_true, assignment=self.CUSTOM_TASK - ) as customcaptcha: - response = await customcaptcha.captcha_handler(imageUrl=self.image_url) - assert 0 == response["errorId"] diff --git a/tests/test_CustomResultHandler.py b/tests/test_CustomResultHandler.py index 2d76d05..f15364c 100644 --- a/tests/test_CustomResultHandler.py +++ b/tests/test_CustomResultHandler.py @@ -15,18 +15,12 @@ class TestAntiCaptcha(MainAntiCaptcha): default_init_params = ["self", "anticaptcha_key", "sleep_time"] default_handler_params = ["self", "task_id"] # get customcaptcha init and task_handler params - aioinit_params = inspect.getfullargspec( - CustomResultHandler.aioCustomResultHandler.__init__ - ) - aiohandler_params = inspect.getfullargspec( - CustomResultHandler.aioCustomResultHandler.task_handler - ) + aioinit_params = inspect.getfullargspec(CustomResultHandler.aioCustomResultHandler.__init__) + aiohandler_params = inspect.getfullargspec(CustomResultHandler.aioCustomResultHandler.task_handler) # get customcaptcha init and task_handler params init_params = inspect.getfullargspec(CustomResultHandler.CustomResultHandler.__init__) - handler_params = inspect.getfullargspec( - CustomResultHandler.CustomResultHandler.task_handler - ) + handler_params = inspect.getfullargspec(CustomResultHandler.CustomResultHandler.task_handler) # check aio module params assert default_init_params == aioinit_params[0] assert default_handler_params == aiohandler_params[0] @@ -40,9 +34,7 @@ class TestAntiCaptcha(MainAntiCaptcha): def test_response_result_handler(self): # prepare client - custom_result = CustomResultHandler.CustomResultHandler( - anticaptcha_key=self.anticaptcha_key_true - ) + custom_result = CustomResultHandler.CustomResultHandler(anticaptcha_key=self.anticaptcha_key_true) # check response type assert isinstance(custom_result, CustomResultHandler.CustomResultHandler) @@ -55,9 +47,7 @@ class TestAntiCaptcha(MainAntiCaptcha): @pytest.mark.asyncio async def test_response_aioresult_handler(self): # prepare client - custom_result = CustomResultHandler.aioCustomResultHandler( - anticaptcha_key=self.anticaptcha_key_true - ) + custom_result = CustomResultHandler.aioCustomResultHandler(anticaptcha_key=self.anticaptcha_key_true) # check response type assert isinstance(custom_result, CustomResultHandler.aioCustomResultHandler) @@ -73,9 +63,7 @@ class TestAntiCaptcha(MainAntiCaptcha): def test_fail_result_handler(self): # prepare client - custom_result = CustomResultHandler.CustomResultHandler( - anticaptcha_key=self.anticaptcha_key_fail - ) + custom_result = CustomResultHandler.CustomResultHandler(anticaptcha_key=self.anticaptcha_key_fail) response = custom_result.task_handler(task_id=self.WRONG_TASK_ID) # check error code @@ -94,9 +82,7 @@ class TestAntiCaptcha(MainAntiCaptcha): @pytest.mark.asyncio async def test_fail_aioresult_handler(self): # prepare client - custom_result = CustomResultHandler.aioCustomResultHandler( - anticaptcha_key=self.anticaptcha_key_fail - ) + custom_result = CustomResultHandler.aioCustomResultHandler(anticaptcha_key=self.anticaptcha_key_fail) response = await custom_result.task_handler(task_id=self.WRONG_TASK_ID) # check error code @@ -119,9 +105,7 @@ class TestAntiCaptcha(MainAntiCaptcha): def test_true_result_handler(self): # prepare client - custom_result = CustomResultHandler.CustomResultHandler( - anticaptcha_key=self.anticaptcha_key_true - ) + custom_result = CustomResultHandler.CustomResultHandler(anticaptcha_key=self.anticaptcha_key_true) response = custom_result.task_handler(task_id=self.WRONG_TASK_ID) # check error code @@ -140,9 +124,7 @@ class TestAntiCaptcha(MainAntiCaptcha): @pytest.mark.asyncio async def test_true_aioresult_handler(self): # prepare client - custom_result = CustomResultHandler.aioCustomResultHandler( - anticaptcha_key=self.anticaptcha_key_true - ) + custom_result = CustomResultHandler.aioCustomResultHandler(anticaptcha_key=self.anticaptcha_key_true) response = await custom_result.task_handler(task_id=self.WRONG_TASK_ID) # check error code diff --git a/tests/test_ImageToText.py b/tests/test_ImageToText.py index b513a33..f2fd54d 100644 --- a/tests/test_ImageToText.py +++ b/tests/test_ImageToText.py @@ -26,9 +26,7 @@ class TestImageToTextCaptcha(MainAntiCaptcha): default_handler_params = ["self", "captcha_link", "captcha_file", "captcha_base64"] # get customcaptcha init and captcha_handler params aioinit_params = inspect.getfullargspec(ImageToTextTask.aioImageToTextTask.__init__) - aiohandler_params = inspect.getfullargspec( - ImageToTextTask.aioImageToTextTask.captcha_handler - ) + aiohandler_params = inspect.getfullargspec(ImageToTextTask.aioImageToTextTask.captcha_handler) # get customcaptcha init and captcha_handler params init_params = inspect.getfullargspec(ImageToTextTask.ImageToTextTask.__init__) @@ -70,9 +68,7 @@ class TestImageToTextCaptcha(MainAntiCaptcha): with requests_mock.Mocker() as req_mock: req_mock.register_uri("GET", self.image_url, json=self.VALID_RESPONSE_JSON) req_mock.register_uri("POST", config.create_task_url, json=self.VALID_RESPONSE_JSON) - req_mock.register_uri( - "POST", config.get_result_url, json=self.VALID_RESPONSE_RESULT_JSON - ) + req_mock.register_uri("POST", config.get_result_url, json=self.VALID_RESPONSE_RESULT_JSON) customcaptcha.captcha_handler(captcha_link=self.image_url) history = req_mock.request_history @@ -102,9 +98,7 @@ class TestImageToTextCaptcha(MainAntiCaptcha): @pytest.mark.asyncio async def test_response_aioimagecaptcha(self): - imagecaptcha = ImageToTextTask.aioImageToTextTask( - anticaptcha_key=self.anticaptcha_key_fail - ) + imagecaptcha = ImageToTextTask.aioImageToTextTask(anticaptcha_key=self.anticaptcha_key_fail) # check response type assert isinstance(imagecaptcha, ImageToTextTask.aioImageToTextTask) diff --git a/tests/test_NoCaptcha.py b/tests/test_NoCaptcha.py index d803a0b..d38d202 100644 --- a/tests/test_NoCaptcha.py +++ b/tests/test_NoCaptcha.py @@ -17,7 +17,7 @@ class TestNoCaptcha(MainAntiCaptcha): def test_nocaptcha_params(self): default_init_params = ["self", "anticaptcha_key", "sleep_time", "callbackUrl"] - default_handler_params = ["self", "websiteURL", "websiteKey", 'recaptchaDataSValue'] + default_handler_params = ["self", "websiteURL", "websiteKey", "recaptchaDataSValue"] # get customcaptcha init and captcha_handler params aioinit_params = inspect.getfullargspec(NoCaptchaTask.aioNoCaptchaTask.__init__) aiohandler_params = inspect.getfullargspec(NoCaptchaTask.aioNoCaptchaTask.captcha_handler) @@ -54,5 +54,7 @@ class TestNoCaptcha(MainAntiCaptcha): # check all dict keys assert ["clientKey", "task", "softId"] == list(request_payload.keys()) assert request_payload["softId"] == config.app_key - assert ["type", "websiteURL", "websiteKey", 'recaptchaDataSValue'] == list(request_payload["task"].keys()) + assert ["type", "websiteURL", "websiteKey", "recaptchaDataSValue"] == list( + request_payload["task"].keys() + ) assert request_payload["task"]["type"] == "NoCaptchaTask" diff --git a/tests/test_Recaptcha3Proxyless.py b/tests/test_Recaptcha3Proxyless.py index 76647ad..ecf3923 100644 --- a/tests/test_Recaptcha3Proxyless.py +++ b/tests/test_Recaptcha3Proxyless.py @@ -16,17 +16,13 @@ class TestAntiCaptcha(MainAntiCaptcha): default_init_params = ["self", "anticaptcha_key", "sleep_time", "callbackUrl"] default_handler_params = ["self", "websiteURL", "websiteKey", "minScore", "pageAction"] # get customcaptcha init and captcha_handler params - aioinit_params = inspect.getfullargspec( - ReCaptchaV3TaskProxyless.aioReCaptchaV3TaskProxyless.__init__ - ) + aioinit_params = inspect.getfullargspec(ReCaptchaV3TaskProxyless.aioReCaptchaV3TaskProxyless.__init__) aiohandler_params = inspect.getfullargspec( ReCaptchaV3TaskProxyless.aioReCaptchaV3TaskProxyless.captcha_handler ) # get customcaptcha init and captcha_handler params - init_params = inspect.getfullargspec( - ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless.__init__ - ) + init_params = inspect.getfullargspec(ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless.__init__) handler_params = inspect.getfullargspec( ReCaptchaV3TaskProxyless.ReCaptchaV3TaskProxyless.captcha_handler )