async def solve_captcha(e: VKError):
logger.error("Captcha. Solving...")
async with aiohttp.ClientSession() as session:
async with session.get(e.raw_error["captcha_img"]) as response_image:
image = await response_image.content.read()
async with session.post(
"https://rucaptcha.com/in.php",
data={
"key": os.environ["RUCAPTCHA_TOKEN"],
"file": image
},
) as response_wait:
result_id = (await response_wait.text()).split("|")[1]
await asyncio.sleep(5)
async with session.get(
"https://rucaptcha.com/res.php",
params={
"key": os.environ["RUCAPTCHA_TOKEN"],
"id": result_id,
"action": "get",
},
) as result:
key = (await result.text()).split("|")[1]
logger.success(f"Captcha was solved. Key: {key}")
return key
async def decorator(*args, **kwargs):
try:
async with ClientSession(json_serialize=json.dumps) as client:
response = await func(*args, **kwargs, client=client)
return response
except Exception:
logger.error(f"Error while requesting:\n{traceback.format_exc()}")
async def run(self, skip_updates: bool, wait: int = DEFAULT_WAIT):
""" Run bot polling forever
Can be manually stopped with:
bot.stop()
"""
self.__wait = wait
logger.debug("Polling will be started. Is it OK?")
if self.__secret is not None:
logger.warning("You set up secret and started polling. Removing secret")
self.__secret = None
if not self.status.dispatched:
self.middleware.add_middleware(self.on.pre)
await self.on.dispatch(self.get_current_rest)
self.status.dispatched = True
if not skip_updates:
await self.get_updates()
await self.get_server()
logger.info("Polling successfully started. Press Ctrl+C to stop it")
while not self._stop:
event = await self.make_long_request(self.long_poll_server)
if isinstance(event, dict) and event.get("ts"):
self.loop.create_task(self.emulate(event))
self.long_poll_server["ts"] = event["ts"]
else:
await self.get_server()
logger.error("Polling was stopped")
async def run(self, wait: int = DEFAULT_WAIT):
""" Run user polling forever
Can be manually stopped with:
>> user.stop()
"""
self.__wait = wait
logger.info("Polling will be started. Is it OK?")
await self.get_server()
self.on.dispatch()
logger.debug("User Polling successfully started")
while not self._stop:
try:
event = await self.make_long_request(self.long_poll_server)
if isinstance(event, dict) and event.get("ts"):
self.__loop.create_task(self.emulate(event))
self.long_poll_server["ts"] = event["ts"]
else:
await self.get_server()
except (
aiohttp.ClientConnectionError,
aiohttp.ServerTimeoutError,
TimeoutError,
):
# No internet connection
logger.warning("Server Timeout Error!")
except:
logger.error(
"While user lp was running error occurred \n\n{}".format(
traceback.format_exc()))
logger.error("Polling was stopped")
async def request(
method: str,
params: dict,
token: str,
session: HTTPRequest = None,
error_handler: "VKErrorHandler" = None,
request_instance=None,
):
url = "{}{method}/?access_token={token}&v={version}".format(
API_URL,
method=method,
token=token,
version=API_VERSION,
)
session = session or HTTPRequest()
response = await session.post(url, data=params or {})
if not isinstance(response, dict):
delay = 1
while not isinstance(response, dict):
logger.error(
"\n---"
f"{time.strftime('%m-%d %H:%M:%S', time.localtime())} - DELAY {delay * 5} sec\n"
f"Check your internet connection. Maybe VK died, request returned: {response}"
f"Error appeared after request: {method}")
await asyncio.sleep(delay * 5)
response = await session.post(url, data=params or {})
logger.success(
f"--- {time.strftime('%m-%d %H:%M:%S', time.localtime())}\n"
f"- METHOD SUCCESS after {5 * sum(range(1, delay))} sec\n"
f"RESPONSE: {response}\n")
if "error" in response:
logger.debug("Error after request {method}, response: {r}",
method=method,
r=response)
exception = VKError(
response["error"]["error_code"],
response["error"]["error_msg"],
from_attr(
Categories,
[method.split(".")[0],
to_snake_case(method.split(".")[1])]
if "." in method else method,
(request_instance, None),
),
params,
raw_error=response["error"],
)
if not error_handler:
raise exception
return await error_handler.handle_error(exception)
return response
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except exception as e:
if ignore:
return e
if exception_handler is not None:
await exception_handler(e, *args, **kwargs)
else:
logger.error(traceback.format_exc())
finally:
logger.debug(
f"{func.__name__} successfully handled with swear")
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except exception as e:
if ignore:
return e
if exception_handler is not None:
await exception_handler(e, *args, **kwargs)
elif just_log:
logger.error(
"While {func} was handling error occurred \n\n{traceback}",
func=func.__name__,
traceback=traceback.format_exc(),
)
finally:
logger.debug(
f"{func.__name__} successfully handled with swear")
async def _processor(self, update: dict, update_code: int, update_fields: list):
try:
data = update, update_code, update_fields
if update_code not in list(map(int, UserEvents)):
logger.warning("Undefined event {}", update_code)
return
event = UserEvents(update_code)
logger.debug("New event: {} {}", event, update)
if event is UserEvents.new_message:
return await self._message_processor(*data)
return await self._event_processor(*data)
except VKError as e:
await self.error_handler.handle_error(e)
except:
logger.error(
"While user polling worked error occurred \n\n{traceback}",
traceback=traceback.format_exc(),
)
async def unhandled_error(self, e: VKError):
logger.error(traceback.format_exc(2))
async def emulate(
self, event: dict, confirmation_token: str = None, secret: str = None,
) -> typing.Union[str, None]:
"""
Process all types of events
:param event: VK Event (LP or CB)
:param confirmation_token: code which confirm VK callback
:param secret: secret key for callback
:return: "ok"
"""
if not self.status.dispatched:
self.middleware.add_middleware(self.on.pre)
await self.on.dispatch(self.get_current_rest)
self.status.dispatched = True
logger.debug("Event: {event}", event=event)
if event is None:
return
if event.get("type") == "confirmation":
if event.get("group_id") == self.group_id:
return confirmation_token or "dissatisfied"
updates = event.get("updates", [event])
if not self._check_secret(event, secret=secret):
logger.debug("Aborted. Secret is invalid")
return "access denied"
for update in updates:
try:
if not update.get("object"):
continue
obj = update["object"]
if update["type"] == EventList.MESSAGE_NEW:
# VK API v5.103
client_info = obj.get("client_info")
if client_info is None:
raise VKError(
0, "Change API version to 5.103 or later"
) from None
obj = obj["message"]
await self._processor(obj, client_info)
else:
await (
self._event_processor(obj=obj, event_type=update["type"])
) # noqa
except VKError as e:
await self.error_handler.handle_error(e)
except:
logger.error(
"While event was emulating error occurred \n\n{traceback}",
traceback=traceback.format_exc(),
)
return "ok"
