def captcha_handler(self, JsSha1: str, JsUri: str, JsData: str,
**kwargs) -> dict:
"""
Метод отвечает за передачу данных на сервер для решения капчи
:param JsSha1: контрольная сумма SHA1 для javascript библиотеки
:param JsUri: URL javascript библиотеки
:param JsData: данные библиотеки, закодированные в base64
:param kwargs: Для передачи дополнительных параметров для `data`
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - всё хорошо, True - есть ошибка,
errorBody - название ошибки
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload["data"].update({key: kwargs[key]})
# добавляем в пайлоад параметры капчи переданные пользователем
self.post_payload["data"].update({
"JsSha1": JsSha1,
"JsUri": JsUri,
"JsData": JsData
})
# получаем ID капчи
captcha_id = requests.post(self.url_request,
data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id["status"] == 0:
self.result.update({
"error": True,
"errorBody": captcha_id["request"]
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
def captcha_handler(self, captcha_text: str, **kwargs):
"""
Метод отвечает за передачу данных на сервер для решения капчи
:param captcha_text: Текстовый вопрос
:param kwargs: Для передачи дополнительных параметров
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
# вводим текст капчи, выбираем метод ПОСТ и ждём ответа. в JSON-формате
self.post_payload.update({"textcaptcha": captcha_text})
# Отправляем на рукапча текст капчи и ждём ответа
# в результате получаем JSON ответ с номером решаемой капчи
captcha_id = requests.post(self.url_request,
data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id["status"] == 0:
self.result.update({
"error":
True,
"errorBody":
RuCaptchaError().errors(captcha_id["request"]),
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
def captcha_handler(self, site_key: str, page_url: str, **kwargs):
'''
Метод отвечает за передачу данных на сервер для решения капчи
:param site_key: Гугл-ключ сайта
:param page_url: Ссылка на страницу на которой находится капча
:param kwargs: Для передачи дополнительных параметров
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
user_check - ID работника, который решил капчу
user_score - score решившего капчу работника
taskId - находится ID задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
'''
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
self.post_payload.update({'googlekey': site_key,
'pageurl': page_url})
# получаем ID капчи
captcha_id = requests.post(self.url_request, data = self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id['status'] == 0:
self.result.update({'error': True,
'errorBody': RuCaptchaError().errors(captcha_id['request'])
}
)
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id['request']
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
# и параметр `taskinfo=1` для получения подробной информации об исполнителе
self.get_payload.update({'id': captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get('pingback'):
return self.get_payload
else:
# Ожидаем решения капчи 10 секунд
time.sleep(self.sleep_time)
return get_sync_result(get_payload = self.get_payload,
sleep_time = self.sleep_time,
url_response = self.url_response,
result = self.result)
def captcha_handler(self, site_key: str, page_url: str, **kwargs):
"""
The method is responsible for transferring data to the server to solve captcha
: param site_key: Website sitekey
: param page_url: Link to the page where the captcha is located
: param kwargs: To pass additional parameters
: return: Answer to the captcha as a JSON string with fields:
captchaSolve - captcha solution,
taskId - is the Id of the task to solve the captcha, can be used for complaints and other things,
error - False - if everything is fine, True - if there is an error,
errorBody - full error information:
{
text - Extended error explanation
id - unique error number in THIS library
}
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
self.post_payload.update({"sitekey": site_key, "pageurl": page_url})
# получаем ID капчи
captcha_id = requests.post(self.url_request,
data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id["status"] == 0:
self.result.update({
"error":
True,
"errorBody":
RuCaptchaError().errors(captcha_id["request"])
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи 10 секунд
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
def captcha_handler(self, public_key: str, page_url: str, **kwargs):
"""
Метод отвечает за передачу данных на сервер для решения капчи
:param public_key: Ключ сайта
:param page_url: Ссылка на страницу на которой находится капча
:param kwargs: Для передачи дополнительных параметров
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - название ошибки
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
# добавляем в пайлоад параметры капчи переданные пользователем
self.post_payload.update({
"publickey": public_key,
"pageurl": page_url
})
# получаем ID капчи
captcha_id = requests.post(self.url_request,
data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id["status"] == 0:
self.result.update({
"error": True,
"errorBody": captcha_id["request"]
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
def captcha_handler(self, challenge: str, **kwargs):
'''
Метод отвечает за передачу данных на сервер для решения капчи
:param challenge: Днамический ключ задания
:param kwargs: Для передачи дополнительных параметров
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
'''
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
# добавляем в пайлоад параметры капчи переданные пользователем
self.post_payload.update({'challenge': challenge})
# получаем ID капчи
captcha_id = requests.post(self.url_request, data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id['status'] == 0:
self.result.update({'error': True,
'errorBody': RuCaptchaError().errors(captcha_id['request'])
}
)
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id['request']
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({'id': captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get('pingback'):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(get_payload=self.get_payload,
sleep_time = self.sleep_time,
url_response = self.url_response,
result = self.result)
def captcha_handler(self, captcha_link: str):
'''
Метод получает от вас ссылку на изображение, скачивает его, отправляет изображение на сервер
RuCaptcha, дожидается решения капчи и вовзращает вам результат
:param captcha_link: Ссылка на изображение
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
'''
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Скачиваем изображение
content = self.session.get(captcha_link).content
# Отправляем изображение файлом
files = {'file': content}
# Отправляем на рукапча изображение капчи и другие парметры,
# в результате получаем JSON ответ с номером решаемой капчи и получая ответ - извлекаем номер
captcha_id = self.session.post(self.url_request, data=self.post_payload, files=files).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id['status'] is 0:
self.result.update({'error': True,
'errorBody': RuCaptchaError().errors(captcha_id['request'])
}
)
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id['request']
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({'id': captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get('pingback'):
return self.get_payload
else:
# Ожидаем решения капчи 20 секунд
time.sleep(self.sleep_time)
return get_sync_result(get_payload=self.get_payload,
sleep_time = self.sleep_time,
url_response = self.url_response,
result = self.result)
def captcha_handler(self, public_key: str, page_url: str):
'''
Метод отвечает за передачу данных на сервер для решения капчи
:param site_key: Ключ сайта
:param page_url: Ссылка на страницу на которой находится капча
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
'''
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# добавляем в пайлоад параметры капчи переданные пользователем
self.post_payload.update({'publickey': public_key,
'pageurl': page_url})
# получаем ID капчи
captcha_id = self.session.post(self.url_request, data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id['status'] is 0:
self.result.update({'error': True,
'errorBody': RuCaptchaError().errors(captcha_id['request'])
}
)
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id['request']
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({'id': captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get('pingback'):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(get_payload=self.get_payload,
sleep_time = self.sleep_time,
url_response = self.url_response,
result = self.result)
def captcha_handler(self, key_params: dict, **kwargs):
"""
Метод отвечает за передачу данных на сервер для решения капчи
:param key_params: Параметры/ключи key-captcha(подробнее в примерах бибилотеки или на сайте RuCaptcha)
:param kwargs: Для передачи дополнительных параметров
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
# считываем все переданные параметры KeyCaptcha
try:
self.post_payload.update({
"s_s_c_user_id":
key_params["s_s_c_user_id"],
"s_s_c_session_id":
key_params["s_s_c_session_id"],
"s_s_c_web_server_sign":
key_params["s_s_c_web_server_sign"],
"s_s_c_web_server_sign2":
key_params["s_s_c_web_server_sign2"],
"pageurl":
key_params["pageurl"],
})
except KeyError as error:
self.result.update({
"error": True,
"errorBody": {
"text": error,
"id": -1
}
})
return self.result
# передаём параметры кей капчи для решения
captcha_id = requests.post(url=self.url_request,
data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id["status"] == 0:
self.result.update({
"error":
True,
"errorBody":
RuCaptchaError().errors(captcha_id["request"]),
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# отправляем запрос на результат решения капчи, если ещё капча не решена - ожидаем 5 сек
# если всё ок - идём дальше
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
def captcha_handler(self,
captcha_link: str = None,
captcha_file: str = None,
captcha_base64: str = None,
**kwargs):
"""
Метод получает от вас ссылку на изображение, скачивает его, отправляет изображение на сервер
RuCaptcha, дожидается решения капчи и вовзращает вам результат
:param captcha_link: Ссылка на изображение
:param captcha_file: Адрес(локальный) по которому находится изображение для отправки на расшифровку
:param captcha_base64: Изображение переданное в кодировке base64
:param kwargs: Параметры для библиотеки `requests`
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# если передана локальная ссылка на файл
if captcha_file:
captcha_id = self.__local_image_captcha(captcha_file)
# если передан файл в кодировке base64
elif captcha_base64:
captcha_id = self.__local_image_captcha(captcha_base64,
content_type="base64")
# если передан URL
elif captcha_link:
try:
content = self.session.get(url=captcha_link, **kwargs).content
except Exception as error:
self.result.update({
'error': True,
'errorBody': {
'text': error,
'id': -1
}
})
return self.result
# согласно значения переданного параметра выбираем функцию для сохранения изображения
if self.save_format == 'const':
captcha_id = self.__image_const_saver(content)
elif self.save_format == 'temp':
captcha_id = self.__image_temp_saver(content)
else:
# если не передан ни один из параметров
self.result.update({
'error':
True,
'errorBody':
'You did not send any file local link or URL.',
})
return self.result
# проверяем наличие ошибок при скачивании/передаче файла на сервер
if self.result['error']:
return self.result
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
elif captcha_id['status'] is 0:
self.result.update({
'error':
True,
'errorBody':
RuCaptchaError().errors(captcha_id['request'])
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id['request']
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({'id': captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get('pingback'):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result)
def captcha_handler(
self,
captcha_link: str = None,
captcha_file: str = None,
captcha_base64: str = None,
**kwargs,
):
"""
Метод получает от вас ссылку на изображение, отправляет изображение на сервер
RuCaptcha, дожидается решения капчи и вовзращает вам результат
:param captcha_link: Ссылка на изображение
:param captcha_file: Адрес(локальный) по которому находится изображение
для отправки на расшифровку
:param captcha_base64: Изображение переданное в кодировке base64
:param kwargs: Параметры для библиотеки `requests`
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - название ошибки
"""
# result, url_request, url_response -
# задаются в декораторе `service_check`, после проверки переданного названия
# если передана локальная ссылка на файл
if captcha_file:
captcha_id = self.__local_image_captcha(captcha_file)
# если передан файл в кодировке base64
elif captcha_base64:
captcha_id = self.__local_image_captcha(captcha_base64, content_type="base64")
# если передан URL
elif captcha_link:
try:
content = self.session.get(url=captcha_link, **kwargs).content
except Exception as error:
self.result.update({"error": True, "errorBody": {"text": error, "id": -1}})
return self.result
# согласно значения переданного параметра выбираем функцию для сохранения изображения
if self.save_format == "const":
captcha_id = self.__image_const_saver(content)
elif self.save_format == "temp":
captcha_id = self.__image_temp_saver(content)
else:
# если не передан ни один из параметров
self.result.update(
{"error": True, "errorBody": "You did not send any file local link or URL."}
)
return self.result
# проверяем наличие ошибок при скачивании/передаче файла на сервер
if self.result["error"]:
return self.result
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
elif captcha_id["status"] == 0:
self.result.update({"error": True, "errorBody": captcha_id["request"]})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
def captcha_handler(self, **kwargs):
'''
Метод отвечает за передачу данных на сервер для решения капчи
:param kwargs: Параметры/ключи key-captcha(подробнее в примерах бибилотеки или на сайте RuCaptcha)
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - полная информация об ошибке:
{
text - Развернётое пояснение ошибки
id - уникальный номер ошибка в ЭТОЙ бибилотеке
}
'''
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# считываем все переданные параметры KeyCaptcha
try:
self.post_payload.update({
's_s_c_user_id':
kwargs['s_s_c_user_id'],
's_s_c_session_id':
kwargs['s_s_c_session_id'],
's_s_c_web_server_sign':
kwargs['s_s_c_web_server_sign'],
's_s_c_web_server_sign2':
kwargs['s_s_c_web_server_sign2'],
'pageurl':
kwargs['pageurl'],
})
except KeyError as error:
self.result.update({
'error': True,
'errorBody': {
'text': error,
'id': -1
}
})
return self.result
# передаём параметры кей капчи для решения
captcha_id = self.session.post(url=self.url_request,
data=self.post_payload).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id['status'] is 0:
self.result.update({
'error':
True,
'errorBody':
RuCaptchaError().errors(captcha_id['request'])
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id['request']
# отправляем запрос на результат решения капчи, если ещё капча не решена - ожидаем 5 сек
# если всё ок - идём дальше
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({'id': captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get('pingback'):
return self.get_payload
else:
# Ожидаем решения капчи
time.sleep(self.sleep_time)
return get_sync_result(get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result)
def captcha_handler(self, captcha_link: str, **kwargs):
"""
Метод получает от вас ссылку на изображение, скачивает его, отправляет изображение на сервер
RuCaptcha, дожидается решения капчи и вовзращает вам результат
:param captcha_link: Ссылка на изображение или путь до файла
:param kwargs: Для передачи дополнительных параметров
:return: Ответ на капчу в виде JSON строки с полями:
captchaSolve - решение капчи,
taskId - находится Id задачи на решение капчи, можно использовать при жалобах и прочем,
error - False - если всё хорошо, True - если есть ошибка,
errorBody - название ошибки
"""
# result, url_request, url_response - задаются в декораторе `service_check`, после проверки переданного названия
# Если переданы ещё параметры - вносим их в get_payload
if kwargs:
for key in kwargs:
self.get_payload.update({key: kwargs[key]})
# Скачиваем изображение
content = (self.session.get(captcha_link).content
if "http" in captcha_link else open(captcha_link, "rb"))
# Отправляем изображение файлом
files = {
"file_1":
("file_1", content, mimetypes.guess_type(captcha_link)[0])
}
# Отправляем на рукапча изображение капчи и другие парметры,
# в результате получаем JSON ответ с номером решаемой капчи и получая ответ - извлекаем номер
captcha_id = self.session.post(self.url_request,
data=self.post_payload,
files=files).json()
# если вернулся ответ с ошибкой то записываем её и возвращаем результат
if captcha_id["status"] == 0:
self.result.update({
"error": True,
"errorBody": captcha_id["request"]
})
return self.result
# иначе берём ключ отправленной на решение капчи и ждём решения
else:
captcha_id = captcha_id["request"]
# вписываем в taskId ключ отправленной на решение капчи
self.result.update({"taskId": captcha_id})
# обновляем пайлоад, вносим в него ключ отправленной на решение капчи
self.get_payload.update({"id": captcha_id})
# если передан параметр `pingback` - не ждём решения капчи а возвращаем незаполненный ответ
if self.post_payload.get("pingback"):
return self.get_payload
else:
# Ожидаем решения капчи 20 секунд
time.sleep(self.sleep_time)
return get_sync_result(
get_payload=self.get_payload,
sleep_time=self.sleep_time,
url_response=self.url_response,
result=self.result,
)
