Update version and fix codestyle + tests
Remove CallbackClient
This commit is contained in:
Andrei D
parent
5987aef872
commit
8df6d9fb78
9
Makefile
9
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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
```
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
# получение результата из кеша
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
# Асинхронный метод работы
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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-",
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
[tool.black]
|
||||
line-length = 99
|
||||
line-length = 110
|
||||
target-version = ['py36']
|
||||
exclude = '''
|
||||
/(
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
||||
|
|
|
|||
|
|
@ -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':<task_id>, 'code':<solve>}
|
||||
"""
|
||||
# если переданы кастомные параметры для подключения к серверу или очереди 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
|
||||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
2
setup.py
2
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__))
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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"]
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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
|
||||
)
|
||||
|
|
|
|||
Loading…
Reference in New Issue