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"